Stratégie de trading adaptative sur grille et mécanisme d'ajustement dynamique

MA EMA SMA VWMA TEMA LREG Grid Trading Elasticity Laziness Cooldown
Date de création: 2025-02-28 10:01:54 Dernière modification: 2025-02-28 10:01:54
Copier: 4 Nombre de clics: 1044
2
Suivre
319
Abonnés

Stratégie de trading adaptative sur grille et mécanisme d’ajustement dynamique Stratégie de trading adaptative sur grille et mécanisme d’ajustement dynamique

Aperçu

La stratégie de négociation de grille auto-adaptative est une stratégie quantitative basée sur un système de négociation de grille qui s’adapte aux changements de marché en ajustant automatiquement la position des lignes de grille. Cette stratégie utilise plusieurs indicateurs techniques pour calculer les meilleurs points de négociation et pour mettre à jour la grille dynamiquement en fonction de l’évolution des prix. L’idée centrale est d’exécuter des opérations d’achat ou de vente dans une fourchette de prix définie, lorsque les prix touchent les lignes de grille prédéfinies, afin de capturer les opportunités de profit engendrées par les fluctuations du marché.

Principe de stratégie

La stratégie est basée sur les composants et principes de base suivants:

  1. Mécanisme de traitement: La stratégie consiste d’abord à lisser les prix, en prenant en charge plusieurs types de moyennes mobiles ((Retrocession linéaire, SMA, EMA, VWMA et TEMA), permettant à l’utilisateur de choisir la méthode de lissage appropriée en fonction de ses préférences.

  2. Paramètre de retard LazinessC’est une innovation clé de la stratégie, en introduisant une fonction de retard lz (), qui ne met à jour le signal que lorsque la variation des prix dépasse un certain pourcentage, filtrant ainsi efficacement le bruit du marché.

  3. La structure de la grille:

    • Point d’ancrage comme centre de la grille, ajusté dynamiquement en fonction de la relation entre les prix et la moyenne mobile
    • L’intervalle de grille détermine la distance entre les lignes de grille adjacentes.
    • Le paramètre d’élasticité (Elasticity) contrôle la sensibilité de l’ajustement du point d’appui
  4. Logistique de génération de signaux:

    • Un signal d’achat est généré lorsque le prix traverse la grille en dessous
    • Un signal de vente est généré lorsque le prix traverse la grille d’en haut
    • Il est possible d’utiliser les hauts et les bas (Highs/Lows) ou les prix de clôture comme conditions de déclenchement du signal
  5. Mécanisme de contrôle des transactions:

    • Cooldown: évitez les transactions fréquentes
    • Le filtre de direction peut être utilisé pour forcer la stratégie de préférence vers le multi-tête, le vide-tête ou le neutre
    • Limiter les transactions à l’intérieur de la grille supérieure et inférieure
  6. Mise à jour du réseau dynamique: Lorsque la moyenne mobile paresseuse (LMA) change, la structure de la grille entière est réajustée pour permettre à la stratégie de s’adapter à la nouvelle fourchette de prix.

La stratégie utilise des matrices pour stocker les prix des lignes de la grille et pour déterminer les points d’achat et de vente spécifiques en calculant la croisée des prix et des lignes de la grille, tout en tenant compte de plusieurs conditions contraignantes pour éviter des transactions inutiles.

Avantages stratégiques

  1. Une grande capacité d’adaptationLe plus grand avantage de cette stratégie réside dans la possibilité d’ajuster automatiquement la position de la grille en fonction des variations du marché, sans intervention humaine. Grâce à des paramètres d’élasticité et à un mécanisme d’ajustement des points d’appui, la grille peut se déplacer en fonction de l’évolution des tendances des prix et rester toujours pertinente.

  2. Filtrage du bruitL’introduction du paramètre de retard Laziness est une innovation qui assure que le réglage de la grille ne soit déclenché que lorsque la variation des prix est suffisamment importante, réduisant efficacement la réponse au bruit du marché et améliorant la stabilité de la stratégie.

  3. Une personnalisation flexible: La stratégie fournit de nombreux paramètres, y compris le nombre de grilles, l’espacement des grilles, les préférences de direction, le type de réglage, etc., que l’utilisateur peut ajuster en fonction des caractéristiques du marché et de son style de négociation personnel.

  4. Zone de négociation visualisée: La stratégie affiche les zones de transactions actives en cours à l’aide d’un remplissage de couleurs, permettant aux traders de voir intuitivement où se situe le prix actuel dans la grille, pour faciliter la prise de décision.

  5. Contrôle des risquesEn limitant les transactions à des grilles spécifiques, la stratégie établit un mécanisme naturel de contrôle des risques pour prévenir les transactions défavorables dans des conditions de marché extrêmes.

  6. Logique d’entrée et de sortie unifiée: Utilisation de la même ligne de grille comme signal d’achat et de vente, pour maintenir la cohérence et la prévisibilité de la logique de transaction.

Risque stratégique

  1. Risque de rupture de frontièreLa stratégie est essentiellement une stratégie de négociation par intervalles et peut faire face à des pertes persistantes dans des marchés en forte tendance. La stratégie peut continuer à prendre des positions dans la mauvaise direction lorsque les prix franchissent les limites inférieures de la grille et se déplacent de manière continue. La solution consiste à ajouter un composant de reconnaissance de tendance ou à suspendre la négociation de la grille lorsque la tendance est confirmée.

  2. Paramètre Sensibilité: La performance de la stratégie dépend fortement des paramètres, en particulier des paramètres de retard (Laziness) et d’élasticité (Elasticity). Des paramètres inappropriés peuvent entraîner un ajustement tardif ou trop sensible de la grille. Il est recommandé d’optimiser ces paramètres en effectuant des retours dans différents environnements de marché.

  3. Risques de la pyramide: la stratégie permet plusieurs entrées dans la même direction ((pyramiding=4), ce qui peut conduire à un excès de levier et à une concentration du risque dans des conditions de marché extrêmes. Il convient de prendre en compte la définition d’une limite de position maximale et la gestion dynamique de la position.

  4. Les points de glissement et les frais de traitement: Les stratégies de négociation de grille impliquent généralement des transactions fréquentes, et dans l’exécution réelle, les points de glissement et les frais de traitement peuvent avoir un impact significatif sur la rentabilité de la stratégie. Ces facteurs doivent être pris en compte dans la rétroévaluation et l’intervalle de grille peut avoir besoin d’être ajusté pour équilibrer la fréquence des transactions avec les coûts.

  5. Traitement des conflits de signaux: Lorsque des signaux d’achat et de vente apparaissent simultanément, la stratégie actuelle choisit d’ignorer les deux signaux, ce qui peut entraîner la perte d’importantes opportunités de négociation. Des signaux conflictuels peuvent être considérés pour être résolus sur la base d’indicateurs de marché ou de modèles de prix supplémentaires.

Orientation de l’optimisation de la stratégie

  1. Adaptation des paramètres: Les stratégies peuvent être optimisées pour ajuster automatiquement l’intervalle de grille et les paramètres de retard en fonction de la volatilité du marché. Par exemple, augmenter l’intervalle de grille dans les marchés à forte volatilité et réduire l’intervalle de grille dans les marchés à faible volatilité, afin de mieux adapter les stratégies aux différentes conditions du marché.

  2. Intégration des composants de détection de tendances: Les stratégies actuelles peuvent être moins performantes dans les marchés tendanciels, et peuvent introduire des indicateurs de reconnaissance de tendance (comme l’ADX, la croisée des moyennes mobiles, etc.) pour ajuster automatiquement la direction de la négociation ou suspendre la grille de négociation lorsqu’une forte tendance est identifiée.

  3. Gestion dynamique des positionsLa stratégie actuelle utilise la taille de position fixe, mais elle peut être améliorée pour une gestion de position dynamique basée sur le calcul du risque, par exemple en ajustant la taille de la position en fonction de l’ATR ou en allouant des fonds en fonction du pourcentage de la valeur nette du compte.

  4. Analyse de plusieurs périodes: Introduction de l’analyse multi-cadres, qui utilise la direction de la tendance des périodes de temps plus longues pour filtrer les signaux de négociation, et exécute les transactions sur la grille uniquement dans la direction de la tendance des cadres de temps plus longs.

  5. Mécanisme de stop loss parfait: La stratégie actuelle manque de mécanisme de stop-loss clair, il est possible d’ajouter un stop-loss global basé sur la situation globale du marché, ou de définir des points de stop-loss séparés pour chaque niveau de grille afin de limiter la perte maximale d’une seule transaction.

  6. Optimisation du temps de jeu: La stratégie peut intégrer des indicateurs de volume ou de dynamique des prix, optimiser les moments d’entrée et de sortie spécifiques avec des conditions de filtrage supplémentaires lors du déclenchement du signal de grille, améliorer le taux de réussite.

  7. Intégration du machine learningIl est possible d’envisager d’optimiser la position de la grille et la sélection des paramètres à l’aide d’algorithmes d’apprentissage automatique, de prévoir les meilleurs réglages de la grille à l’aide de modèles de formation de données historiques et d’améliorer encore l’adaptabilité de la stratégie.

Résumer

La stratégie de négociation de grille auto-adaptative résout le problème du manque de flexibilité des stratégies de négociation de grille traditionnelles grâce à une fonction de retard innovante et à un mécanisme d’ajustement de grille dynamique. Elle est capable de s’adapter automatiquement aux changements de marché, de capturer des opportunités de négociation dans différentes fourchettes de prix, tout en contrôlant le comportement des transactions via une variété de paramètres.

Malgré les problèmes potentiels tels que le risque de rupture de zone et la sensibilité des paramètres, la stratégie a le potentiel d’obtenir une performance stable dans divers environnements de marché en intégrant des directions d’optimisation telles que l’identification de tendances et l’ajustement des paramètres dynamiques. Dans la pratique, il est recommandé de vérifier la performance de la stratégie en effectuant un retour complet, en particulier dans différentes conditions de marché, et d’ajuster les paramètres en fonction des caractéristiques de la variété de transaction spécifique, afin d’obtenir un effet optimal.

Code source de la stratégie
//@version=5
// This source code is subject to the terms of the Mozilla Public License 2.0 https://mozilla.org/MPL/2.0/
// ©mvs1231 || xxattaxx

strategy(title='Grid Bot Auto Strategy', shorttitle='GridBot', initial_capital = 100000, overlay=true, pyramiding=4,  default_qty_type = strategy.fixed, default_qty_value = 0, commission_value = 0.04, commission_type = strategy.commission.percent, margin_long = 0, margin_short = 0, process_orders_on_close = true)
//----<User Inputs>------------------------------------------------------------------------------//
iLen = input.int(7, 'Smoothing Length(7)', minval=1)
iMA = input.string('lreg', 'Smoothing Type', options=['lreg', 'sma', 'ema', 'vwma', 'tema'])
iLZ = input.float(4.0, 'Laziness(4%)', step=.25) / 100
iELSTX = input(50.0, 'Elasticity(50)')
iGI = input.float(2.0, 'Grid Interval(2%)', step=.25) / 100
iGrids = input.int(6, 'Number of Grids', options=[2, 4, 6, 8])
iCool = input.int(2, 'Cooldown(2)', minval=0)
iDir = input.string('neutral', 'Direction', options=['neutral', 'up', 'down'])
iGT = input.int(70, 'Grid Line Transparency(100 to hide)', minval=0, maxval=100)
iFT = input.int(90, 'Fill Transparency(100 to hide)', minval=0, maxval=100)
iSS = input.string('small', 'Signal Size', options=['small', 'large'])
iReset = input(true, 'Reset Buy/Sell Index When Grids Change')
iEXTR = input(true, 'Use Highs/Lows for Signals')
iMT = input(true, 'Show Min Tick')
iRFC = input(false, 'Reverse Fill Colors')
qty_ent = iGrids/2 
qty_pos = strategy.initial_capital / qty_ent / 2 / open
//----<Colors>-----------------------------------------------------------------------------------//
RedGrid = color.new(color.red, iGT)
GreenGrid = color.new(color.green, iGT)
Crimson = #DC143C
LimeGreen = #32CD32
//----<Variables>--------------------------------------------------------------------------------//
NextUP = 0.0
NextDN = 0.0
LastSignal = 0
LastSignal_Index = 0
AP = 0.0
G = iGrids
Buy = false
Sell = false
UpperLimit = 0.0
LowerLimit = 0.0
SignalLine = 0.0
CurrentGrid = 0.0
BuyLine = 0.0
SellLine = 0.0
DIR = 0
MeaningOfLife = 42
//----<Calculations>-----------------------------------------------------------------------------//
//Lazy Formula
lz(x, lzf) =>
    LZ = 0.0
    s = math.sign(x)
    LZ := x == nz(x[1], x) ? x : x > nz(LZ[1] + lzf * LZ[1] * s, x) ? x : x < nz(LZ[1] - lzf * LZ[1] * s, x) ? x : LZ[1]
    LZ
//Smoothing
LR = ta.linreg(close, iLen, 0)
SMA = ta.sma(close, iLen)
EMA = ta.ema(close, iLen)
VWMA = ta.vwma(close, iLen)
TEMA = ta.ema(ta.ema(ta.ema(close, iLen), iLen), iLen)
MA = iMA == 'lreg' ? LR : iMA == 'sma' ? SMA : iMA == 'ema' ? EMA : iMA == 'vwma' ? VWMA : TEMA
//Make Lazy
LMA = lz(MA, iLZ)
//Calculate Elasticity
ELSTX = syminfo.mintick * iELSTX
//Show Mintick
if iMT and barstate.islast
    table.cell(table.new(position.top_right, 1, 1), 0, 0, str.tostring(syminfo.mintick))
//Anchor Point
AP := MA > LMA ? AP[1] + ELSTX : MA < LMA ? AP[1] - ELSTX : AP[1]
AP := AP >= NextUP[1] ? NextUP[1] : AP
AP := AP <= NextDN[1] ? NextDN[1] : AP
//Reset if Next Level Reached or AP is crossed
AP := LMA != LMA[1] ? LMA : AP
//Next Gridlines
NextUP := LMA != LMA[1] ? LMA + LMA * iGI : NextUP[1]
NextDN := LMA != LMA[1] ? LMA - LMA * iGI : NextDN[1]
//Grid Interval
GI = AP * iGI
//----<Grid Array>-------------------------------------------------------------------------------//
a_grid = array.new_float(9)
for x = -4 to 4 by 1
    array.set(a_grid, x + 4, AP + GI * x)
Get_Array_Values(ArrayName, index) =>
    value = array.get(ArrayName, index)
    value
//----<Set Static Grids>-------------------------------------------------------------------------//
G0 = Get_Array_Values(a_grid, 0)  //Upper4
G1 = Get_Array_Values(a_grid, 1)  //Upper3
G2 = Get_Array_Values(a_grid, 2)  //Upper2
G3 = Get_Array_Values(a_grid, 3)  //Upper1
G4 = Get_Array_Values(a_grid, 4)  //Center
G5 = Get_Array_Values(a_grid, 5)  //Lower1
G6 = Get_Array_Values(a_grid, 6)  //Lower2
G7 = Get_Array_Values(a_grid, 7)  //Lower3
G8 = Get_Array_Values(a_grid, 8)  //Lower4
//----<Set Upper and Lower Limits>---------------------------------------------------------------//
UpperLimit := G >= 8 ? G8 : G >= 6 ? G7 : G >= 4 ? G6 : G5
LowerLimit := G >= 8 ? G0 : G >= 6 ? G1 : G >= 4 ? G2 : G3
//----<Calculate Signals>------------------------------------------------------------------------//
Get_Signal_Index() =>
    Value = 0.0
    Buy_Index = 0
    Sell_Index = 0
    start = 4 - G / 2
    end = 4 + G / 2
    for x = start to end by 1
        Value := Get_Array_Values(a_grid, x)
        if iEXTR
            Sell_Index := low[1] < Value and high >= Value ? x : Sell_Index
            Buy_Index := high[1] > Value and low <= Value ? x : Buy_Index
            Buy_Index
        else
            Sell_Index := close[1] < Value and close >= Value ? x : Sell_Index
            Buy_Index := close[1] > Value and close <= Value ? x : Buy_Index
            Buy_Index
    [Buy_Index, Sell_Index]
[BuyLine_Index, SellLine_Index] = Get_Signal_Index()
//----<Signals>----------------------------------------------------------------------------------//
Buy := BuyLine_Index > 0 ? true : Buy
Sell := SellLine_Index > 0 ? true : Sell
//No repeat trades at current level                                                                                     
Buy := low >= SignalLine[1] - GI ? false : Buy
Sell := high <= SignalLine[1] + GI ? false : Sell
//No trades outside of grid limits
Buy := close > UpperLimit ? false : Buy
Buy := close < LowerLimit ? false : Buy
Sell := close < LowerLimit ? false : Sell
Sell := close > UpperLimit ? false : Sell
//Direction Filter (skip one signal if against market direction)
DIR := iDir == 'up' ? 1 : iDir == 'down' ? -1 : 0
Buy := DIR == -1 and low >= SignalLine[1] - GI * 2 ? false : Buy
Sell := DIR == 1 and high <= SignalLine[1] + GI * 2 ? false : Sell
//Conflicting Signals
if Buy and Sell
    Buy := false
    Sell := false
    LastSignal_Index := LastSignal_Index[1]
    LastSignal_Index
//----<Cooldown>---------------------------------------------------------------------------------//
y = 0
for i = 1 to iCool by 1
    if Buy[i] or Sell[i]
        y := 0
        break
    y += 1
    y
CoolDown = y
Buy := CoolDown < iCool ? false : Buy
Sell := CoolDown < iCool ? false : Sell
//----<Trackers>---------------------------------------------------------------------------------//
LastSignal := Buy ? 1 : Sell ? -1 : LastSignal[1]
LastSignal_Index := Buy ? BuyLine_Index : Sell ? SellLine_Index : LastSignal_Index[1]
SignalLine := Get_Array_Values(a_grid, LastSignal_Index)
//Reset to Center Grid when LMA changes
if iReset
    SignalLine := LMA < LMA[1] ? UpperLimit : SignalLine
    SignalLine := LMA > LMA[1] ? LowerLimit : SignalLine
    SignalLine
BuyLine := Get_Array_Values(a_grid, BuyLine_Index)
SellLine := Get_Array_Values(a_grid, SellLine_Index)
//----<Plot Grids>--------------------------//
color apColor = na
apColor := MA < AP ? color.new(color.red, iGT) : MA > AP ? color.new(color.green, iGT) : apColor[1]
apColor := LMA != LMA[1] ? na : apColor
plot(G >= 8 ? G0 : na, color=GreenGrid)
plot(G >= 6 ? G1 : na, color=GreenGrid)
plot(G >= 4 ? G2 : na, color=GreenGrid)
plot(G >= 2 ? G3 : na, color=GreenGrid)
plot(G4, color=apColor, linewidth=4)  // Center
plot(G >= 2 ? G5 : na, color=RedGrid)
plot(G >= 4 ? G6 : na, color=RedGrid)
plot(G >= 6 ? G7 : na, color=RedGrid)
plot(G >= 8 ? G8 : na, color=RedGrid)
//fill 
LineAbove = SignalLine == UpperLimit ? SignalLine : SignalLine + GI
LineBelow = SignalLine == LowerLimit ? SignalLine : SignalLine - GI
a = plot(LineAbove, color=color.new(color.red, 100), style=plot.style_circles)
b = plot(LineBelow, color=color.new(color.green, 100), style=plot.style_circles)
boxColor = LastSignal == 1 ? color.new(color.green, iFT) : color.new(color.red, iFT)
if iRFC
    boxColor := LastSignal == -1 ? color.new(color.green, iFT) : color.new(color.red, iFT)
    boxColor
fill(a, b, color=boxColor)
//----<Plot Signals>-----------------------------------------------------------------------------//
plotchar(Buy and iSS == 'small', 'Buy', color=color.new(LimeGreen, 0), size=size.tiny, location=location.belowbar, char='▲')
plotchar(Sell and iSS == 'small', 'Sell', color=color.new(Crimson, 0), size=size.tiny, location=location.abovebar, char='▼')
plotchar(Buy and iSS == 'large', 'Buy', color=color.new(LimeGreen, 0), size=size.small, location=location.belowbar, char='▲')
plotchar(Sell and iSS == 'large', 'Sell', color=color.new(Crimson, 0), size=size.small, location=location.abovebar, char='▼')
//----<Alerts>-----------------------------------------------------------------------------------//
alertcondition(condition=Buy, title='buy', message='buy')
alertcondition(condition=Sell, title='sell', message='sell')
//-----------------------------------------------------------------------------------------------//
if strategy.position_size >= 0 and Buy
    strategy.entry("Long", strategy.long, qty = qty_pos)
if strategy.position_size <= 0 and Sell
    strategy.entry("Short", strategy.short, qty = qty_pos)

if strategy.position_size > 0 and Sell
    strategy.close("Long", qty = qty_pos)

if strategy.position_size < 0 and Buy
    strategy.close("Short", qty = qty_pos)