Stratégie de trading à court terme basée sur le suivi des tendances et l'indicateur ADX


Date de création: 2024-01-22 17:10:55 Dernière modification: 2024-01-22 17:10:55
Copier: 0 Nombre de clics: 687
1
Suivre
1617
Abonnés

Stratégie de trading à court terme basée sur le suivi des tendances et l’indicateur ADX

Aperçu

Cette stratégie combine les indicateurs de tendance supérieure (Super Trend), les points pivots (Pivot Points) et les lignes de stop-loss dynamiques formées par l’amplitude réelle moyenne (Average True Range, ATR), ainsi que l’indicateur de direction moyenne (Average Directional Movement Index, ADX) pour permettre le jugement et le suivi de la tendance. La stratégie convient aux transactions sur des lignes courtes, car elle permet de capturer la partie de la continuation de la tendance après la compilation du disque intermédiaire.

Principe de stratégie

L’indicateur hypertrend décide de l’orientation de la position en combinant les points pivots et les arrêts ATR pour déterminer la direction dans laquelle le prix a franchi la ligne de perte dynamique. L’indicateur ADX, quant à lui, détermine la force de la tendance et n’émet un signal de transaction que lorsque la tendance est suffisamment forte.

En particulier, le point pivot est le support le plus récent de la résistance, puis forme un prix moyen dynamique avec la moyenne arithmétique des deux premiers jours. Ensuite, ATR est calculé et multiplié par le facteur ATR, puis ajouté et diminué avec le prix moyen dynamique, pour obtenir la montée et la descente.

Les lignes de stop-loss sont dynamiquement ajustées en fonction des prix les plus récents et des valeurs ATR, ce qui permet de suivre les tendances.

Analyse des avantages

Cette stratégie présente les avantages suivants:

  1. L’indicateur hypertrend permet de suivre la direction de la tendance et d’éviter d’être pris au piège par les chocs.

  2. L’ADX permet de déterminer la force de la tendance et d’éviter les erreurs de négociation lors de la consolidation.

  3. La ligne de stop-loss est ajustée dynamiquement pour maximiser le profit.

  4. En combinaison avec le RSI, il a évité de faire des achats et des ventes.

  5. Dans l’ensemble, la définition des paramètres de la stratégie est raisonnable, la sélection du dframe prend en compte la continuité et le paramètre de stop-loss est bon.

Analyse des risques

Cette stratégie comporte aussi des risques:

  1. Les indicateurs de tendance supérieure et les indicateurs de MA peuvent être en conflit.

  2. L’indicateur ADX est réglé sur 14 cycles et est insuffisamment sensible aux événements soudains.

  3. Le paramètre RSI est défini par défaut et peut ne pas être entièrement évité.

  4. L’impact d’événements inattendus, tels que des pertes importantes ou des nouvelles positives, n’est pas pris en compte.

La réponse:

  1. Ajustez le cycle de la MA pour qu’il soit en phase avec l’indicateur de tendance supérieure.

  2. Essayez de raccourcir le cycle ADX et d’augmenter la sensibilité aux événements soudains.

  3. Optimiser le paramètre RSI pour trouver la valeur optimale

  4. En ajoutant le filtrage des nouvelles, vous éviterez les gros titres.

Direction d’optimisation

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

  1. L’augmentation des tendances de jugement des modèles d’apprentissage automatique pour rendre les décisions de négociation plus intelligentes.

  2. Essayez d’introduire des indicateurs ADX alternatifs comme les indicateurs émotionnels pour évaluer la force de la tendance.

  3. L’ajout d’un module d’arrêt de perte d’adaptation pour rendre l’arrêt de perte plus dynamique et précis.

  4. L’apprentissage en profondeur permet d’extraire plus de données et d’optimiser la stratégie globale.

  5. L’utilisation de langages avancés tels que Python pour le développement de stratégies, pour augmenter l’évolutivité des stratégies.

Résumer

Cette stratégie est très pratique dans l’ensemble, son cœur est de suivre la direction de la tendance et de participer lorsque la tendance est suffisamment forte. Les paramètres d’arrêt et de freinage sont également bien placés pour maximiser le blocage des profits et éviter l’expansion des pertes. Bien sûr, il y a encore beaucoup de place pour l’optimisation, si l’on ajoute des techniques d’apprentissage automatique et d’apprentissage en profondeur, cela rendra les effets de la stratégie plus excellents, mais aussi plus extensibles et universels.

Code source de la stratégie
/*backtest
start: 2023-01-15 00:00:00
end: 2024-01-21 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=5
strategy("Bendre ADX STrend", overlay = true)

///////////////////////////
// SuperTrend + Pivot Point
//////////////////////////

src =  input(close, title="EMA Source")
PPprd = input(defval = 2, title="Pivot Point Period")
AtrFactor=input(defval = 2, title = "ATR Factor")
AtrPd=input(defval = 21, title = "ATR Period")

StartDate = input(timestamp("1 Dec 2023"), title="Start Date")
EndDate = input(timestamp("12 Jan 2024"), title="End Date")
window()  => true

var float ph = na
var float pl = na
ph := ta.pivothigh(PPprd, PPprd)
pl :=ta.pivotlow(PPprd, PPprd)

float center = na
center := center[1]
// float lastpp = ph ? ph : pl ? pl : 0.0
float lastpp = na(ph) ? na(pl) ? na : pl : ph

if lastpp > 0
    if na(center)
        center := lastpp
    else
        center := (center * 2 + lastpp) / 3

Up = center - (AtrFactor * ta.atr(AtrPd))
Dn = center + (AtrFactor * ta.atr(AtrPd))

var float TUp = na
var float TDown = na
Trend = 0
TUp := close[1] > TUp[1] ? math.max(Up, TUp[1]) : Up
TDown := close[1] < TDown[1] ? math.min(Dn, TDown[1]) : Dn
Trend := close > TDown[1] ? 1: close < TUp[1]? -1: nz(Trend[1], 1)
Trailingsl = Trend == 1 ? TUp : TDown

// Lines
linecolor = Trend == 1 and nz(Trend[1]) == 1 ? color.lime : Trend == -1 and nz(Trend[1]) == -1 ? color.red : na
plot(Trailingsl, color = linecolor ,  linewidth = 2, title = "PP SuperTrend")

bsignalSSPP = close > Trailingsl
ssignalSSPP = close < Trailingsl


///////
// ADX
//////

lenADX = 14
th = 14
TrueRange = math.max(math.max(high-low, math.abs(high-nz(close[1]))), math.abs(low-nz(close[1])))
DirectionalMovementPlus = high-nz(high[1]) > nz(low[1])-low ? math.max(high-nz(high[1]), 0): 0
DirectionalMovementMinus = nz(low[1])-low > high-nz(high[1]) ? math.max(nz(low[1])-low, 0): 0
SmoothedTrueRange = 0.0
SmoothedTrueRange := nz(SmoothedTrueRange[1]) - (nz(SmoothedTrueRange[1])/lenADX) + TrueRange
SmoothedDirectionalMovementPlus = 0.0
SmoothedDirectionalMovementPlus := nz(SmoothedDirectionalMovementPlus[1]) - (nz(SmoothedDirectionalMovementPlus[1])/lenADX) + DirectionalMovementPlus
SmoothedDirectionalMovementMinus = 0.0
SmoothedDirectionalMovementMinus := nz(SmoothedDirectionalMovementMinus[1]) - (nz(SmoothedDirectionalMovementMinus[1])/lenADX) + DirectionalMovementMinus
DIPlus = SmoothedDirectionalMovementPlus / SmoothedTrueRange * 100
DIMinus = SmoothedDirectionalMovementMinus / SmoothedTrueRange * 100
DX = math.abs(DIPlus-DIMinus) / (DIPlus+DIMinus)*100
ADX = ta.sma(DX, lenADX)


//////
// MA
/////

lenMA = 21
srcMA = input(close, title="Source")
// offsetMA = input(title="Offset", type=input.integer, defval=0, minval=-500, maxval=500)
offsetMA = input(0, title="Offset")
outMA = ta.sma(srcMA, lenMA)

//
// RSI
//
length = input( 14 )
overSold = input( 30 )
overBought = input( 65 )
price = close
vrsi = ta.rsi(price, length)

//
// DMI - Direction Movement Index
// 
[diplus1, diminus1, adx] = ta.dmi(14, 14)

// Buy - Sell Entries
buy = bsignalSSPP and outMA < close and ADX > th
sell = ssignalSSPP 


if (buy and vrsi > overBought and adx > 19)
    // .order // Tuned version
    strategy.entry("Buy", strategy.long, when = window())
    // strategy.close("Sell", "close Sell")

if (sell) and (strategy.position_size > 0)
    // strategy.entry("Sell", strategy.short)
    strategy.close("Buy", "Close Buy")

if(sell and vrsi < overSold and adx > 25)
    strategy.entry("Sell", strategy.short, when = window())

if ( ta.crossover( diminus1, diplus1) or ((buy) and (strategy.position_size > 0)) )
    strategy.close("Sell", "close Sell")

// if(sell) and (diminus1 > diplus1) and adx > 23 and adx > adx[1] and (vrsi < overSold)
//     strategy.entry("Sell", strategy.short, when = window())

// if (strategy.position_size > 0 and ta.crossunder(diminus1, adx)) or (strategy.position_size > 0  and (buy))
//     strategy.close("Sell", "close Sell")