Comment Maîtriser les Trailing Stop Loss en Pine Script sur TradingView

La gestion efficace des méthodes de sortie est cruciale pour réussir en trading. Cela comprend la gestion des risques et la protection contre les variations de prix qui pourraient compromettre votre stratégie. Parmi ces méthodes, le trailing stop loss est une option dynamique qui s'intègre dans ce cadre.

Ce dispositif peut être avantageux dans les marchés à forte tendance, où il peut surpasser la combinaison traditionnelle du stop loss et du take profit. Toutefois, dans les marchés volatils, il présente des limites : le trailing stop loss risque d'être activé prématurément en raison de pics de volatilité, et non en réponse à une réelle inversion de tendance.

Pour ajouter cet outil à votre arsenal de trading, voyons comment coder un trailing stop loss facilement en Pine Script. Nous explorerons deux méthodes : une méthode simple utilisant les fonctionnalités de base de TradingView, et une méthode plus versatile. Nous nous concentrerons uniquement sur le trailing stop loss dans cet article. Si vous souhaitez apprendre à coder un stop loss et un take profit en Pine Script, vous pouvez lire cet article.

Comprendre et Utiliser Efficacement les Ordres Trailing Stop Loss (Stop Suiveurs)

Un ordre de trailing stop loss, tout comme un stop loss classique, est un ordre de fermeture de position. Cependant, il se distingue par sa capacité à s'ajuster dynamiquement en fonction des mouvements favorables du marché. Contrairement à un stop loss fixe, le trailing stop loss se déplace automatiquement avec les hausses de prix pour une position long ou avec les baisses pour une position short, tout en restant fixe si le prix évolue dans la direction opposée.

En pratique, voici comment cela fonctionne :

1. Définition de la Distance de Suivi : Le trader spécifie une distance, généralement en pourcentage ou en points, par rapport au prix actuel.
2. Ajustement Automatique : Si le marché évolue favorablement, le trailing stop loss se réajuste pour maintenir la distance prédéfinie. En cas de baisse du prix (pour une position long), il reste au niveau atteint.
3. Exécution de l'Ordre : Si le marché atteint le niveau du trailing stop loss en évoluant défavorablement, l'ordre est déclenché, fermant ainsi la position.

Le prix d'exécution est donc dynamique. Les approches pour définir la distance de suivi incluent :

• Pourcentage par rapport au prix d'entrée : Par exemple, un trailing stop loss fixé à 5% sous le prix actuel pour une position long.
• Indicateur de volatilité : Utilisation de l'Average True Range (ATR) ou d'autres indicateurs pour déterminer la distance de suivi. Pour plus de détails sur l'ATR, rendez-vous ici.

Programmer un Trailing Stop Loss en Pine Script sur TradingView : Guide Complet

Exemple de Stratégie de Trading Simple en Pine Script

Pour illustrer l’implémentation d’un ordre de trailing stop loss, reprenons l’exemple de la stratégie présentée dans notre article sur les ordres take profit et stop loss en Pine Script. Elle utilise des bandes de Bollinger pour ses règles d'entrée. Le code se trouve ci-dessous :

//@version=5
strategy('TSL example', default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.1, overlay=true)

// *** Indicator *** 
bb_length = input(20, title="BB Length")
bb_mult = input(2, title="BB Multiplier")

bb_stddev = ta.stdev(close, bb_length)
bb_average = ta.sma(close, bb_length)

bb_upper = bb_average + bb_mult * bb_stddev
bb_lower = bb_average - bb_mult * bb_stddev

// *** Signals ***
entry_long = ta.crossover(close, bb_upper)
entry_short = ta.crossunder(close, bb_lower)

Si vous souhaitez plus d’explications sur les éléments de ce code, consultez l’article correspondant.

Coder un Trailing Stop Loss en Pine Script : Méthode Directe et Rapide

Il existe deux façons d’implémenter un trailing stop loss en Pine Script. La première méthode utilise les paramètres intégrés dans la fonction strategy.exit() de Pine Script, qui gère les sorties de position. L’autre est une implémentation légèrement plus complexe, mais beaucoup plus versatile, permettant notamment de fixer le niveau du trailing suivant des valeurs d’indicateurs et pas uniquement selon un écart de prix.

Examinons d'abord la première méthode. Elle est très directe lorsque l’on souhaite simplement établir le trailing stop loss selon un écart par rapport au prix de l’actif. Il est souvent pertinent d’exprimer cet écart en pourcentage. Par exemple, pour un écart de 5% par rapport au close du prix, cela donne en Pine Script :

trail_percent = 0.05
tsl_offset  = close * trail_percent / syminfo.mintick
tsl_price = close

Ici, nous avons converti l'écart donné en pourcentage en ticks dans tsl_offset. C'est ce que la fonction strategy.exit() requiert ainsi que tsl_price. En résumé :

• tsl_price est le prix d’activation de l’ordre trailing stop loss. Ce n’est pas le prix d’exécution, celui-ci est déterminé automatiquement par TradingView selon le tsl_offset.
• tsl_offset correspond à l’écart par rapport au prix d’activation tsl_price.

Une fois ces paramètres correctement établis, nous pouvons ajouter les sorties comme suit :

trail_percent = 0.05
tsl_offset  = close * trail_percent / syminfo.mintick
tsl_price = close

if entry_long and strategy.position_size == 0
    strategy.entry("Long", strategy.long)
    strategy.exit("Long", trail_price = tsl_price, trail_offset = tsl_offset , comment_trailing = "TSL Long")

if entry_short and strategy.position_size == 0
    strategy.entry("Short", strategy.short)
    strategy.exit("Short", trail_price = tsl_price, trail_offset = tsl_offset , comment_trailing = "TSL Short")

Nous avons aussi spécifié un tag comment_trailing qui sera affiché sur le graphique TradingView sur la bougie à laquelle le trailing stop loss est exécuté, comme ceci :

Coder un Trailing Stop Loss en Pine Script : Méthode Avancée et Versatile

Si l’on souhaite fixer le prix d'exécution du trailing stop loss selon un indicateur, il faut être capable de mettre à jour continuellement l’ordre via strategy.exit(). Dans ce cas, il peut être plus facile de réaliser soi-même le calcul du niveau du trailing stop loss à chaque bougie.

Prenons comme exemple un trailing stop loss calculé selon un écart par rapport au close, tabulé sur la volatilité de l’actif. Choisissons donc d’utiliser l’indicateur ATR (pour plus d’informations sur cet indicateur et comment l’utiliser comme filtre de volatilité, consultez cet article).

D’abord, définissons nos entrées puisque les sorties seront gérées indépendamment en fonction de l'évolution du trailing :

entry_long = ta.crossover(close, bb_upper)
entry_short = ta.crossunder(close, bb_lower)

if entry_long and strategy.position_size == 0
    strategy.entry("Long", strategy.long)
if entry_short and strategy.position_size == 0
    strategy.entry("Short", strategy.short)

Ensuite, calculons l’ATR et fixons que le niveau du trailing stop loss doit correspondre à un écart de 3 fois l’ATR par rapport au close du prix :

atr_length = 14
atr = ta.atr(atr_length)
long_tsl = close - 3 * atr
short_tsl = close + 3 * atr

Maintenant, nous devons mettre en place la logique du trailing stop loss. Autrement dit, nous devons faire en sorte que le prix de l’ordre stop loss se mette à jour uniquement si le prix évolue favorablement pour notre position, en fonction du mouvement des prix et de l'indicateur. Sinon, le prix du stop loss doit rester identique à celui de la bougie précédente. Cela donne en Pine Script :

long_stop_price = 0.0
long_stop_price := if strategy.position_size > 0
    math.max(long_tsl, long_stop_price[1])
else
    0

short_stop_price = 0.0
short_stop_price := if strategy.position_size < 0
    math.min(short_tsl, short_stop_price[1])
else
    999999

Notez que cette logique est implémentée grâce à la fonction math.max dans le cas d’une position long. Nous vérifions si la valeur de long_tsl est supérieure au prix du stop loss de la bougie précédente (long_stop_price[1]). Si c'est le cas, cela signifie que le prix a évolué favorablement. Si une position long est effectivement ouverte (if strategy.position_size > 0), alors long_stop_price prendra la valeur retournée par math.max, c'est-à-dire long_tsl dans ce cas. Si le prix a évolué défavorablement, long_tsl sera inférieur à long_stop_price[1], et math.max retournera le prix du stop loss de la bougie précédente. La logique est inverse pour une position short.

Il nous reste à mettre en place la sortie via un stop loss :

if strategy.position_size > 0
    strategy.exit(id='TSL Long', stop=long_stop_price)

if strategy.position_size < 0
    strategy.exit(id='TSL Short', stop=short_stop_price)

Ce qui sera automatiquement mis à jour à chaque bougie. Maintenant, ajoutons un plot du trailing stop loss, ce qui peut grandement aider pour étudier la stratégie en jeu et ses performances. Récapitulons le code complet :

//@version=5
strategy('Versatile TSL Example', overlay=true, default_qty_value=100, commission_value=0.1, default_qty_type=strategy.percent_of_equity, commission_type=strategy.commission.percent)

// Indicators
bb_length = 20
bb_mult = 2
atr_length = 14

atr = ta.atr(atr_length)
bb_stddev = ta.stdev(close, bb_length)
bb_average = ta.sma(close, bb_length)
bb_upper = bb_average + bb_mult * bb_stddev
bb_lower = bb_average - bb_mult * bb_stddev

// Entries
entry_long = ta.crossover(close, bb_upper)
entry_short = ta.crossunder(close, bb_lower)

if entry_long and strategy.position_size == 0
    strategy.entry("Long", strategy.long)
if entry_short and strategy.position_size == 0
    strategy.entry("Short", strategy.short)

// Compute the trailing stop loss prices
long_tsl = close - 3 * atr
short_tsl = close + 3 * atr

// Check and update the stop loss depending on price movement
long_stop_price = 0.0
long_stop_price := if (strategy.position_size > 0)
    math.max(long_tsl, long_stop_price[1])
else
    0

short_stop_price = 0.0
short_stop_price := if (strategy.position_size < 0)
    math.min(short_tsl, short_stop_price[1])
else
    999999

// Exit orders
if strategy.position_size > 0
    strategy.exit(id='TSL Long', stop=long_stop_price)

if strategy.position_size < 0
    strategy.exit(id='TSL Short', stop=short_stop_price)

// Plots
plot(bb_upper, color=color.new(#ffb13b, 0), linewidth=2)
plot(bb_average, color=color.new(#b43bff, 0), linewidth=2)
plot(bb_lower, color=color.new(#ffb13b, 0), linewidth=2)
plot(series=strategy.position_size > 0 ? long_stop_price : na, color=color.rgb(49, 122, 241), style=plot.style_cross, linewidth=3)
plot(series=strategy.position_size < 0 ? short_stop_price : na, color=color.rgb(49, 122, 241), style=plot.style_cross, linewidth=3)

Pour conclure, il est important de noter que tout ceci était un exemple simple pour vous apprendre à coder un trailing stop loss en Pine Script. Pour qu’une stratégie soit viable et utilisable avec de l’argent réel, il faut beaucoup plus de tests et de validations. Gardez cela en tête. Cet article était éducatif et non un conseil en investissement. Nous espérons que cela vous a apporté les bases que vous cherchiez pour implémenter vos stratégies.

Nous souhaitons également vous mettre en garde contre une utilisation abusive du trailing stop loss. Bien qu'il s'agisse d'une méthode très populaire sur les réseaux sociaux et parmi les traders débutants, elle n'est pas une solution miracle. L’efficacité du trailing stop loss est limitée. Il peut fonctionner correctement lors de fortes tendances, mais génère souvent de nombreux faux signaux et mauvaises sorties lorsque le marché est en phase latérale. De plus, il implique un retard au niveau de la sortie, car il se déclenche uniquement lorsque le prix a déjà commencé à évoluer défavorablement. Dans de telles situations, il peut être plus efficace de configurer la sortie en utilisant des indicateurs plus adaptés à la stratégie en place.