Modèle de retournement de cassure basé sur la stratégie Turtle Trader
ChaoZhang
Aperçu
La stratégie est basée sur la célèbre stratégie de l’opérateur de la mer de Guinée, qui a été validée pendant de nombreuses années. Elle envoie des signaux de positions longues et vides, et peut être utilisée jusqu’à 5 fois pour les ordres pyramidaux, ce qui signifie que la stratégie peut déclencher jusqu’à 5 ordres dans la même direction.
Il est important de noter que cette stratégie combine deux systèmes qui travaillent ensemble (S1 et S2).
Principe de stratégie
La taille de la position est très importante pour les traders de forex afin de bien gérer le risque. La stratégie d’ajustement de la position s’adapte à la volatilité du marché et au compte de gains et pertes. Elle est basée sur l’ATR (la portée réelle moyenne).
Le nombre d’unités achetées est le suivant:
unit = (percentage_to_risk/100)*account/atr*syminfo.pointvalue
Vous pouvez augmenter le pourcentage de votre compte en fonction de vos préférences en matière de risque, mais les traders Turtles prennent 1% par défaut. Si vous négociez des contrats, l’unité doit être intégrée par défaut.
Il y a aussi une règle supplémentaire pour réduire le risque lorsque la valeur comptable est inférieure au capital initial: dans ce cas, la formule unitaire doit être remplacée par la formule suivante:
account := (strategy.equity-strategy.openprofit)*(strategy.equity-strategy.openprofit)/strategy.initial_capital
Il y a deux systèmes qui fonctionnent ensemble: Une rupture est un nouveau sommet ou un nouveau bas. Si c’est un nouveau sommet, nous ouvrons une position en plus, et inversement, si c’est un nouveau bas, nous entrons dans une position vide.
Nous ajoutons une règle supplémentaire: Cette règle supplémentaire permet aux traders de participer à la tendance principale si le signal du système 1 est sauté. Si le signal du système 1 est sauté et que la ligne K suivante est également une nouvelle rupture de 20 jours, le S1 n’émettra pas de signal.
Analyse des avantages
Les stratégies de plage nous permettent d’ajouter des unités supplémentaires à notre position lorsque la tendance du prix est favorable pour nous. J’ai configuré la stratégie pour permettre d’ajouter jusqu’à 5 commandes dans la même direction.
Nous définissons la première commande comme étant la commande maximale. Les commandes pyramidales suivantes seront moins nombreuses que la première commande.
Nous avons fixé un maximum de stop loss de 10% pour la première commande, ce qui signifie que vous ne perdrez pas plus de 10% de la valeur de la première commande.*ATR ((20), vos ordres pyramidaux risquent de perdre plus, et ne sont pas assurés de perdre moins de 10%. Le risque est toujours bien géré, car ces ordres sont moins importants que la première commande.
Analyse des risques
Le plus grand risque de cette stratégie est de détenir une position trop importante. En raison de l’utilisation de bons de marché pour les ordres sous-traités, si plusieurs bons de marché énormes sont déposés en même temps, il y aura un impact important sur les offres, ce qui entraînera un glissement important. Cela entraînera une perte de fonds considérable.
Un autre risque est la mauvaise configuration de la gestion des fonds. Une configuration erronée ou trop grande peut entraîner des pertes énormes. Cela nécessite une configuration prudente en fonction de vos préférences en matière de risque.
Direction d’optimisation
Cette stratégie peut être optimisée dans les domaines suivants:
Il est possible de tester l’influence de différents paramètres sur le taux de rendement et le Sharpe ratio, tels que le cycle ATR, le multiplicateur ATR de l’arrêt de perte, etc.; trouver la combinaison optimale de paramètres.
Différentes règles d’entrée et de sortie peuvent être testées, par exemple en utilisant la forme de la ligne K comme condition de filtrage supplémentaire.
On peut essayer d’autres types d’arrêt, comme l’arrêt mobile, l’arrêt dynamique. Cela peut réduire la probabilité que l’arrêt soit battu.
Il est possible de tester un nombre différent d’ordres pyramidaux. Plus il y a d’ordres, plus le levier et le risque sont importants. Trouver le meilleur équilibre.
Il est possible d’essayer d’arrêter de négocier pendant une certaine période (par exemple, avant la publication des données sur l’emploi non agricole aux États-Unis) pour éviter l’impact d’un événement majeur.
Résumer
La stratégie est globalement bien équilibrée entre les risques et les gains et convient aux transactions sur des courbes de tendance moyennes et longues. Elle présente des avantages tels que la systématisation des transactions, la maîtrise des risques.
/*backtest
start: 2023-12-01 00:00:00
end: 2023-12-31 23:59:59
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © gsanson66
//This strategy is based on the famous "Turtle Strategy"
//A well-known strategy which proved its performance during past years
//@version=5
strategy("TURTLE STRATEGY", overlay=true)
//------------------------------TOOL TIPS--------------------------------//
t1 = "Percentage of the account the trader is willing to lose. This percentage is used to define the position size based on previous gains or losses. Turtle traders default to 1%."
t2 = "ATR Length"
t3 = "ATR Multiplier to fix the Stop Loss"
t4 = "Pyramiding : ATR Multiplier to set a profit target to increase position size"
t5 = "System 1 enter long if there is a new high after this selected period of time"
t6 = "System 2 enter long if there is a new high after this selected period of time"
t7 = "Exit Long from system 1 if there is a new low after this selected period of time"
t8 = "Exit Long from system 2 if there is a new low after this selected period of time"
t9 = "System 1 enter short if there is a new low after this selected period of time"
t10 = "System 2 enter short if there is a new low after this selected period of time"
t11 = "Exit short from system 1 if there is a new high after this selected period of time"
t12 = "Exit short from system 2 if there is a new high after this selected period of time"
//----------------------------------------FUNCTIONS---------------------------------------//
//@function Displays text passed to `txt` when called.
debugLabel(txt, color) =>
label.new(bar_index, high, text=txt, color=color, style=label.style_label_lower_right, textcolor=color.black, size=size.small)
//@function which looks if the close date of the current bar falls inside the date range
inBacktestPeriod(start, end) => true
//---------------------------------------USER INPUTS--------------------------------------//
//Risk Management and turtle system input
percentage_to_risk = input.float(1, "Risk % of capital", maxval=100, minval=0, group="Turtle Parameters", tooltip=t1)
atr_period = input.int(20, "ATR period", minval=1, group="Turtle Parameters", tooltip=t2)
stop_N_multiplier = input.float(1.5, "Stop ATR", minval=0.1, group="Turtle Parameters", tooltip=t3)
pyramid_profit = input.float(0.5, "Pyramid Profit", minval=0.01, group="Turtle Parameters", tooltip=t4)
S1_long = input.int(20, "S1 Long", minval=1, group="Turtle Parameters", tooltip=t5)
S2_long = input.int(55, "S2 Long", minval=1, group="Turtle Parameters", tooltip=t6)
S1_long_exit = input.int(10, "S1 Long Exit", minval=1, group="Turtle Parameters", tooltip=t7)
S2_long_exit = input.int(20, "S2 Long Exit", minval=1, group="Turtle Parameters", tooltip=t8)
S1_short = input.int(15, "S1 Short", minval=1, group="Turtle Parameters", tooltip=t9)
S2_short = input.int(55, "S2 Short", minval=1, group="Turtle Parameters", tooltip=t10)
S1_short_exit = input.int(7, "S1 Short Exit", minval=1, group="Turtle Parameters", tooltip=t11)
S2_short_exit = input.int(20, "S2 Short Exit", minval=1, group="Turtle Parameters", tooltip=t12)
//Backtesting period
startDate = input(title="Start Date", defval=timestamp("1 Jan 2020 00:00:00"), group="Backtesting Period")
endDate = input(title="End Date", defval=timestamp("1 July 2034 00:00:00"), group="Backtesting Period")
//----------------------------------VARIABLES INITIALISATION-----------------------------//
//Turtle variables
atr = ta.atr(atr_period)
var float buy_price_long = na
var float buy_price_short = na
var float stop_loss_long = na
var float stop_loss_short = na
float account = na
//Entry variables
day_high_syst1 = ta.highest(high, S1_long)
day_low_syst1 = ta.lowest(low, S1_short)
day_high_syst2 = ta.highest(high, S2_long)
day_low_syst2 = ta.lowest(low, S2_short)
var bool skip = false
var bool unskip_buffer_long = false
var bool unskip_buffer_short = false
//Exit variables
exit_long_syst1 = ta.lowest(low, S1_long_exit)
exit_short_syst1 = ta.highest(high, S1_short_exit)
exit_long_syst2 = ta.lowest(low, S2_long_exit)
exit_short_syst2 = ta.highest(high, S2_short_exit)
float exit_signal = na
//Backtesting period
bool inRange = na
//------------------------------CHECKING SOME CONDITIONS ON EACH SCRIPT EXECUTION-------------------------------//
strategy.initial_capital = 50000
//Checking if the date belong to the range
inRange := inBacktestPeriod(startDate, endDate)
//Checking if the current equity is higher or lower than the initial capital to adjusted position size
if strategy.equity - strategy.openprofit < strategy.initial_capital
account := (strategy.equity-strategy.openprofit)*(strategy.equity-strategy.openprofit)/strategy.initial_capital
else
account := strategy.equity - strategy.openprofit
//Checking if we close all trades in case where we exit the backtesting period
if strategy.position_size!=0 and not inRange
strategy.close_all()
debugLabel("END OF BACKTESTING PERIOD : we close the trade", color=color.rgb(116, 116, 116))
//--------------------------------------SKIP MANAGEMENT------------------------------------//
//Checking if a long signal has been skiped and system2 is not triggered
if skip and high>day_high_syst1[1] and high<day_high_syst2[1]
unskip_buffer_long := true
//Checking if a short signal has been skiped and system2 is not triggered
if skip and low<day_low_syst1[1] and low>day_low_syst2[1]
unskip_buffer_short := true
//Checking if current high is lower than previous 20_day_high after a skiped long signal to set skip to false
if unskip_buffer_long
if high<day_high_syst1[1]
skip := false
unskip_buffer_long := false
//Checking if current low is higher than previous 20_day_low after a skiped short signal to set skip to false
if unskip_buffer_short
if low>day_low_syst1[1]
skip := false
unskip_buffer_short := false
//Checking if we have an open position to reset skip and unskip buffers
if strategy.position_size!=0 and skip
skip := false
unskip_buffer_long := false
unskip_buffer_short := false
//--------------------------------------------ENTRY CONDITIONS--------------------------------------------------//
//We calculate the position size based on turtle calculation
unit = (percentage_to_risk/100)*account/atr*syminfo.pointvalue
//Long order for system 1
if not skip and not (strategy.position_size>0) and inRange
strategy.cancel("Long Syst 2")
//We check that position size doesn't exceed available equity
if unit*day_high_syst1>account
unit := account/day_high_syst1
stop_loss_long := day_high_syst1 - stop_N_multiplier*atr
//We adjust SL if it's greater than 10% of trade value and fix it to 10%
if stop_loss_long < day_high_syst1*0.9
stop_loss_long := day_high_syst1*0.9
strategy.order("Long Syst 1", strategy.long, unit, stop=day_high_syst1)
buy_price_long := day_high_syst1
//Long order for system 2
if skip and not (strategy.position_size>0) and inRange
//We check that position size doesn't exceed available equity
if unit*day_high_syst2>account
unit := account/day_high_syst2
stop_loss_long := day_high_syst2 - stop_N_multiplier*atr
//We adjust SL if it's greater than 10% of trade value and fix it to 10%
if stop_loss_long < day_high_syst2*0.9
stop_loss_long := day_high_syst2*0.9
strategy.order("Long Syst 2", strategy.long, unit, stop=day_high_syst2)
buy_price_long := day_high_syst2
//Short order for system 1
if not skip and not (strategy.position_size<0) and inRange
strategy.cancel("Short Syst 2")
//We check that position size doesn't exceed available equity
if unit*day_low_syst1>account
unit := account/day_low_syst1
stop_loss_short := day_low_syst1 + stop_N_multiplier*atr
//We adjust SL if it's greater than 10% of trade value and fix it to 10%
if stop_loss_short > day_low_syst1*1.1
stop_loss_short := day_low_syst1*1.1
strategy.order("Short Syst 1", strategy.short, unit, stop=day_low_syst1)
buy_price_short := day_low_syst1
//Short order for system 2
if skip and not (strategy.position_size<0) and inRange
//We check that position size doesn't exceed available equity
if unit*day_low_syst2>account
unit := account/day_low_syst2
stop_loss_short := day_low_syst2 + stop_N_multiplier*atr
//We adjust SL if it's greater than 10% of trade value and fix it to 10%
if stop_loss_short > day_low_syst2*1.1
stop_loss_short := day_low_syst2*1.1
strategy.order("Short Syst 2", strategy.short, unit, stop=day_low_syst2)
buy_price_short := day_low_syst2
//-------------------------------PYRAMIDAL------------------------------------//
//Pyramid for long orders
if close > buy_price_long + (pyramid_profit*atr) and strategy.position_size>0
//We calculate the remaining capital
remaining_capital = account - strategy.position_size*strategy.position_avg_price*(1-0.0018)
//We calculate units to add to the long position
units_to_add = (percentage_to_risk/100)*remaining_capital/atr*syminfo.pointvalue
if remaining_capital > units_to_add
//We set the new Stop loss
stop_loss_long := stop_loss_long + pyramid_profit*atr
strategy.entry("Pyramid Long", strategy.long, units_to_add)
buy_price_long := close
//Pyramid for short orders
if close < buy_price_short - (pyramid_profit*atr) and strategy.position_size<0
//We calculate the remaining capital
remaining_capital = account + strategy.position_size*strategy.position_avg_price*(1-0.0018)
//We calculate units to add to the short position
units_to_add = (percentage_to_risk/100)*remaining_capital/atr*syminfo.pointvalue
if remaining_capital > units_to_add
//We set the new Stop loss
stop_loss_short := stop_loss_short - pyramid_profit*atr
strategy.entry("Pyramid Short", strategy.short, units_to_add)
buy_price_short := close
//----------------------------EXIT ORDERS-------------------------------//
//Checking if exit_long_syst1 is higher than stop_loss_long
if strategy.opentrades.entry_id(0)=="Long Syst 1"
if exit_long_syst1[1] > stop_loss_long
exit_signal := exit_long_syst1[1]
else
exit_signal := stop_loss_long
//Checking if exit_long_syst2 is higher than stop_loss_long
if strategy.opentrades.entry_id(0)=="Long Syst 2"
if exit_long_syst2[1] > stop_loss_long
exit_signal := exit_long_syst2[1]
else
exit_signal := stop_loss_long
//Checking if exit_short_syst1 is lower than stop_loss_short
if strategy.opentrades.entry_id(0)=="Short Syst 1"
if exit_short_syst1[1] < stop_loss_short
exit_signal := exit_short_syst1[1]
else
exit_signal := stop_loss_short
//Checking if exit_short_syst2 is lower than stop_loss_short
if strategy.opentrades.entry_id(0)=="Short Syst 2"
if exit_short_syst2[1] < stop_loss_short
exit_signal := exit_short_syst2[1]
else
exit_signal := stop_loss_short
//If the exit order is configured to close the position at a profit, we set 'skip' to true (we substract commission)
if strategy.position_size*exit_signal>strategy.position_size*strategy.position_avg_price*(1-0.0018)
strategy.cancel("Long Syst 1")
strategy.cancel("Short Syst 1")
skip := true
if strategy.position_size*exit_signal<=strategy.position_size*strategy.position_avg_price*(1-0.0018)
skip := false
//We place stop exit orders
if strategy.position_size > 0
strategy.exit("Exit Long", stop=exit_signal)
if strategy.position_size < 0
strategy.exit("Exit Short", stop=exit_signal)
//------------------------------PLOTTING ELEMENTS-------------------------------//
plotchar(atr, "ATR", "", location.top, color.rgb(131, 5, 83))
//Plotting enter threshold
plot(day_high_syst1[1], "20 day high", color.rgb(118, 217, 159))
plot(day_high_syst2[1], "55 day high", color.rgb(4, 92, 53))
plot(day_low_syst1[1], "20 day low", color.rgb(234, 108, 108))
plot(day_low_syst2[1], "55 day low", color.rgb(149, 17, 17))
//Plotting Exit Signal
plot(exit_signal, "Exit Signal", color.blue, style=plot.style_circles)
//Plotting our position
exit_long_syst2_plot = plot(exit_long_syst2[1], color=na)
day_high_syst2_plot = plot(day_high_syst2[1], color=na)
exit_short_syst2_plot = plot(exit_short_syst2[1], color=na)
day_low_syst2_plot = plot(day_low_syst2[1], color=na)
fill(exit_long_syst2_plot, day_high_syst2_plot, color=strategy.position_size>0 ? color.new(color.lime, 90) : na)
fill(exit_short_syst2_plot, day_low_syst2_plot, color=strategy.position_size<0 ? color.new(color.red, 90) : na)