Élevez vos systèmes de trading linéaires au rang de puissance
209
0
Introduction
L'article d'aujourd'hui montre aux programmeurs MQL5 intermédiaires comment ils peuvent tirer plus de bénéfice de leurs systèmes de trading linéaire (Fixed Lot) en implémentant facilement la technique dite de l'exponentiation. Le terme général d'exponentiation est utilisé ici pour désigner les modèles de gestion monétaire qui adaptent la taille ou le nombre des positions placées sur le marché en fonction du risque que l'on prend. En effet, la croissance de la courbe d'équité qui en résulte est alors géométrique, ou exponentielle, prenant la forme d'une parabole. Le terme "linéaire" est également utilisé dans le présent contexte qui est à mi-chemin entre le mathématique et la programmation. Plus précisément, nous mettrons en œuvre une variante pratique MQL5 du dimensionnement de la position fractionnée fixe développée par Ralph Vince.
Figure 1. Parabole mathématique
Faisons maintenant un bref résumé des modèles de gestion de l'argent et voyons comment nous pouvons implémenter une variante du dimensionnement de la position fractionnée fixe de Ralph Vince. Êtes-vous prêt ? Ne manquez pas l'opportunité d'obtenir beaucoup plus de vos stratégies de trading !
1. Quels sont les modèles de gestion de l'argent ?
En un mot, les modèles de gestion de l'argent sont les cadres conceptuels dans lesquels vous prenez des décisions concernant la taille de vos positions, l'utilisation de vos stop loss, vos calculs de marge et vos coûts de trading. Il existe de nombreux modèles de gestion de l'argent ! Si vous le souhaitez, vous pouvez rechercher sur Google un lot fixe, une fraction fixe, un rapport fixe, un pourcentage de Kelly ou un coût effectif pour approfondir vos connaissances sur ces cadres classiques. Comme je l'ai dit, cet article ne couvre qu'une variante de fraction fixe.
1.2. Fraction fixe
L'idée derrière ce modèle de gestion de l'argent est de dimensionner les opérations en fonction du risque estimé qui leur est associé. Le risque est la même fraction du net sur chaque trade.
L'équation du nombre de contrats en dimensionnement de la position fractionnée fixe est la suivante :
N = f * Équité / Risque de trading
N est le nombre de contrats, f est la fraction fixe (un nombre entre 0 et 1), Équité est la valeur actuelle d’équité du compte et Risque de trading est le risque de trading par contrat pour lequel le nombre de contrats est calculé . Veuillez lire l'article Dimensionnement de la position fractionnée fixe écrit par Michael R. Bryant pour en savoir plus sur ce modèle.
Une propriété intéressante du modèle de Fraction Fixe est que puisque la taille des opérations est maintenue proportionnelle au solde net du compte, il est théoriquement impossible de perdre tout votre capital. Le risque de ruine est nul. D'autre part, comme les pourcentages de capital-risque sont plus faibles, une série d'opérations gagnantes ou perdantes n'a pas un impact dramatique sur la courbe de bénéfices.
2. Ajouter des fractions fixes à votre système de trading
2.1. Prenez votre système de trading linéaire
Bien sûr, tout d'abord, vous avez besoin d'un système de trading linéaire pour expérimenter la puissance exponentielle à faible risque ! Ce système servira de base de pouvoir, pour ainsi dire. Par système linéaire, j'entends un système de trading qui s'avère gagnant pendant un certain temps et dont la courbe des capitaux propres ressemble à une ligne droite. Par exemple, HawaiianTsunamiSurfer est un système de trading linéaire disponible dans Code Base. Sa courbe d'équité ressemble à une ligne droite de janvier 2012 à mars 2012.
Figure 2. Courbe d'équité d’HawaiianTsunamiSurfer de janvier 2012 à mars 2012
Le but de cet article n'est pas de développer un système de trading linéaire à partir de zéro, mais de vous donner les outils nécessaires pour que vous puissiez tirer le meilleur parti de vos systèmes. Donc, à partir de maintenant, je suppose que vous avez déjà développé un système de trading comme celui-ci sous le paradigme orienté objet. Dans ce cas, vous devez ajouter la pièce OO, que j'explique ci-dessous.
2.2. CEvolution, la classe Core MQL5 pour élever votre système à la puissance
Donc, encore une fois, nous adoptons l'approche orientée objet pour coder notre EA. Je vous recommande de lire d'abord les articles Another MQL5 OOP class et Building an Automatic News Trader pour obtenir les bases techniques permettant de travailler de cette manière OO. Si vous l'avez déjà fait, gardez à l'esprit que les conceptions décrites dans ces articles intègrent un élément très important nommé CEvolution. Cela nous permet de garder une trace de certaines informations temporelles importantes telles que l'état du robot à un moment donné, l'historique des opérations effectuées, etc.
Cette fois nous allons coder dans CEvolution la logique nécessaire à la gestion de notre argent. Comme la fraction fixe risquée reste proportionnelle à l'équité, dans laquelle nous convenons tous qu'elle n'est pas constante, mais variable, cette logique doit être codée dans CEvolution. Ou simplement, comme la pente de la courbe d'équité évolue avec le temps, c'est dans CEvolution que tout cela doit être mis en œuvre. C'est l'idée abstraite de notre conception orientée objet. C'est un exercice pour vous d'intégrer la classe OO suivante avec votre système de trading de style orienté objet.
Classe CEvolution.mqh :
//+------------------------------------------------------------------+ //| CEvolution.mqh | //| Copyright © 2013, Jordi Bassagañas | //+------------------------------------------------------------------+ #include <Mine\Enums.mqh> //+------------------------------------------------------------------+ //| CEvolution Class | //+------------------------------------------------------------------+ class CEvolution { protected: ENUM_STATUS_EA m_status; // The current EA's status ENUM_EXP_EQUITY_CURVE_LEVEL m_expEquityLevel; // The current exponential equity level double m_originalEquity; // The original equity value double m_lotSize; // The current lot size public: //--- Constructor and destructor methods CEvolution(ENUM_STATUS_EA status,ENUM_EXP_EQUITY_CURVE_LEVEL exp_equity_level); ~CEvolution(void); //--- Getter methods ENUM_STATUS_EA GetStatus(void); ENUM_EXP_EQUITY_CURVE_LEVEL GetExpEquityLevel(void); double GetOriginalEquity(void); double GetLotSize(void); //--- Setter methods void SetStatus(ENUM_STATUS_EA status); void SetExpEquityLevel(ENUM_EXP_EQUITY_CURVE_LEVEL exp_equity_level); void SetOriginalEquity(double equity); void SetLotSize(double size); //--- CEvolution specific methods double CalcEquityGrowth(double currentEquity); void RefreshExpEquityLevel(double currentEquity); void RefreshLotSize(); }; //+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CEvolution::CEvolution(ENUM_STATUS_EA status,ENUM_EXP_EQUITY_CURVE_LEVEL exp_equity_level) { m_status=status; m_expEquityLevel=exp_equity_level; RefreshLotSize(); m_originalEquity=AccountInfoDouble(ACCOUNT_EQUITY); } //+------------------------------------------------------------------+ //| Destructor | //+------------------------------------------------------------------+ CEvolution::~CEvolution(void) { } //+------------------------------------------------------------------+ //| GetStatus | //+------------------------------------------------------------------+ ENUM_STATUS_EA CEvolution::GetStatus(void) { return m_status; } //+------------------------------------------------------------------+ //| GetExpEquityLevel | //+------------------------------------------------------------------+ ENUM_EXP_EQUITY_CURVE_LEVEL CEvolution::GetExpEquityLevel(void) { return m_expEquityLevel; } //+------------------------------------------------------------------+ //| GetEquity | //+------------------------------------------------------------------+ double CEvolution::GetOriginalEquity(void) { return m_originalEquity; } //+------------------------------------------------------------------+ //| GetLotSize | //+------------------------------------------------------------------+ double CEvolution::GetLotSize(void) { return m_lotSize; } //+------------------------------------------------------------------+ //| SetStatus | //+------------------------------------------------------------------+ void CEvolution::SetStatus(ENUM_STATUS_EA status) { m_status=status; } //+------------------------------------------------------------------+ //| SetExpEquityLevel | //+------------------------------------------------------------------+ void CEvolution::SetExpEquityLevel(ENUM_EXP_EQUITY_CURVE_LEVEL exp_equity_level) { m_expEquityLevel=exp_equity_level; } //+------------------------------------------------------------------+ //| SetEquity | //+------------------------------------------------------------------+ void CEvolution::SetOriginalEquity(double equity) { m_originalEquity=equity; } //+------------------------------------------------------------------+ //| SetLotSize | //+------------------------------------------------------------------+ void CEvolution::SetLotSize(double lot_size) { m_lotSize=lot_size; } //+------------------------------------------------------------------+ //| CalcEquityGrowth | //+------------------------------------------------------------------+ double CEvolution::CalcEquityGrowth(double currentEquity) { return NormalizeDouble(currentEquity * 100 / m_originalEquity - 100,2); } //+------------------------------------------------------------------+ //| RefreshExpEquityLevel | //+------------------------------------------------------------------+ void CEvolution::RefreshExpEquityLevel(double currentEquity) { double growth = CalcEquityGrowth(currentEquity); //--- is the current equity less than 10% of the original amount? if(growth <= 10) { SetExpEquityLevel(LEVEL_ONE); } //--- is the current equity more than 10% of the original amount and less than 20%? else if(growth > 10 && growth <= 20) { SetExpEquityLevel(LEVEL_TWO); } //--- is the current equity more than 20% of the original amount and less than 30%? else if(growth > 20 && growth <= 30) { SetExpEquityLevel(LEVEL_THREE); } //--- is the current equity more than 30% of the original amount and less than 40%? else if(growth > 30 && growth <= 40) { SetExpEquityLevel(LEVEL_FOUR); } //--- is the current equity more than 40% of the original amount and less than 50%? else if(growth > 40 && growth <= 50) { SetExpEquityLevel(LEVEL_FIVE); } //--- is the current equity more than 50% of the original amount and less than 60%? else if(growth > 50 && growth <= 60) { SetExpEquityLevel(LEVEL_SEVEN); } //--- is the current equity more than 60% of the original amount and less than 70%? else if(growth > 60 && growth <= 70) { SetExpEquityLevel(LEVEL_EIGHT); } //--- is the current equity more than 70% of the original amount and less than 80%? else if(growth > 70 && growth <= 80) { SetExpEquityLevel(LEVEL_NINE); } //--- is the current equity more than 90% of the original amount? else if(growth > 90) { SetExpEquityLevel(LEVEL_TEN); } } //+------------------------------------------------------------------+ //| RefreshLotSize | //+------------------------------------------------------------------+ void CEvolution::RefreshLotSize() { switch(m_expEquityLevel) { case LEVEL_ONE: SetLotSize(0.01); break; case LEVEL_TWO: SetLotSize(0.02); break; case LEVEL_THREE: SetLotSize(0.03); break; case LEVEL_FOUR: SetLotSize(0.04); break; case LEVEL_FIVE: SetLotSize(0.05); break; case LEVEL_SIX: SetLotSize(0.06); break; case LEVEL_SEVEN: SetLotSize(0.07); break; case LEVEL_EIGHT: SetLotSize(0.08); break; case LEVEL_NINE: SetLotSize(0.09); break; case LEVEL_TEN: SetLotSize(0.1); break; } } //+------------------------------------------------------------------+
Commentons maintenant quelques parties importantes de cette classe !
Lorsque l'Expert Advisor est créé, la valeur de la courbe d'équité d'origine est stockée dans m_originalEquity :
//+------------------------------------------------------------------+ //| Constructor | //+------------------------------------------------------------------+ CEvolution::CEvolution(ENUM_STATUS_EA status,ENUM_EXP_EQUITY_CURVE_LEVEL exp_equity_level) { m_status=status; m_expEquityLevel=exp_equity_level; RefreshLotSize(); m_originalEquity=AccountInfoDouble(ACCOUNT_EQUITY); }
La méthode CEvolution::CalcEquityGrowth permet de calculer la croissance de la courbe d'équité, toujours par rapport à sa valeur d'origine :
//+------------------------------------------------------------------+ //| CalcEquityGrowth | //+------------------------------------------------------------------+ double CEvolution::CalcEquityGrowth(double currentEquity) { return NormalizeDouble(currentEquity * 100 / m_originalEquity - 100,2); }
Enfin, CEvolution::RefreshExpEquityLevel sert à actualiser le niveau d'équité à chaque tick (observez comment cela dépend absolument de la croissance d'équité) et CEvolution::RefreshLotSize sert à actualiser la taille du lot à chaque tick. En effet, vous êtes censé actualiser ces informations dans la méthode OnTick de votre EA de cette façon :
GetEvolution().RefreshExpEquityLevel(AccountInfoDouble(ACCOUNT_EQUITY)); GetEvolution().RefreshLotSize();
Soit dit en passant, cette solution nécessite l'utilisation de l'énumération MQL5 personnalisée suivante :
//+------------------------------------------------------------------+ //| Exponential equity curve level enumeration | //+------------------------------------------------------------------+ enum ENUM_EXP_EQUITY_CURVE_LEVEL { LEVEL_ONE, LEVEL_TWO, LEVEL_THREE, LEVEL_FOUR, LEVEL_FIVE, LEVEL_SIX, LEVEL_SEVEN, LEVEL_EIGHT, LEVEL_NINE, LEVEL_TEN };On dit que cette implémentation est une variante de Fraction Fixe car en effet elle introduit quelques spécificités. Par exemple, la courbe d'équité croîtra de façon exponentielle jusqu'à atteindre le soi-disant niveau dix, par la suite le système deviendra linéaire. Néanmoins, CEvolution retient l'idée de base d'augmenter constamment la taille des positions proportionnellement à la courbe d'équité.
2.3. Prendre vos décisions en matière de fraction fixe
Avec tout ce qui précède, vous pouvez déjà prendre vos décisions de gestion de l'argent en fonction de l'état actuel de votre robot.
Quelque part dans la méthode OnTick de votre EA :
switch(GetEvolution().GetStatus()) { case BUY: tp = ask + m_takeProfit * _Point; sl = bid - m_stopLoss * _Point; GetTrade().PositionOpen(GetBrain().GetSymbol(),ORDER_TYPE_BUY,m_evolution.GetLotSize(),ask,sl,tp); break; case SELL: sl = ask + m_takeProfit * _Point; tp = bid - m_stopLoss * _Point; GetTrade().PositionOpen(GetBrain().GetSymbol(),ORDER_TYPE_SELL,m_evolution.GetLotSize(),bid,sl,tp); break; case DO_NOTHING: // Nothing... break; }
J'ai renommé mon nouveau système exponentiel en ExponentialHawaiian.
3. Backtesting de votre système exponentiel
Une fois que vous avez ajouté la logique OO expliquée ci-dessus à votre système, n'oubliez pas de lancer vos tests ! Maintenant, je teste ExponentialHawaiian, la variante de fraction fixe de HawaiianTsunamiSurfer :
Figure 3. Courbe d'équité d’ExponentialHawaiiande janvier 2012 à mars 2012
La courbe ci-dessus restera exponentielle tandis que le système sous-jacent restera linéaire. Lorsque cette condition n'est plus vraie, le système devient instable avec un risque théorique de ruine.
Conclusion
Aujourd'hui, nous avons appris à tirer davantage des bénéfices de nos systèmes de trading linéaire, ceux qui mettent en œuvre un modèle de gestion de l'argent à lot fixe, en les élevant à la puissance de l'exponentiation.
Nous avons commencé par présenter quelques modèles classiques de money management (Lot Fixe, Fraction Fixe, Ratio fixe, Pourcentage de Kelly, Coût effectif) et avons décidé de nous concentrer sur le modèle de Fraction Fixe, un modèle simple dans lequel la taille des opérations est maintenue proportionnelle au solde net du compte. Enfin, nous avons pris un système de trading affichant des résultats linéaires pendant une période de temps, nous avons implémenté dans MQL5 une variante de Fraction Fixe et montré les résultats lancés par le Strategy Tester de MetaTrader.
Une fois de plus, nous avons adopté l'approche orientée objet pour coder nos Expert Advisors. Il est fortement recommandé de lire d'abord les articles Another MQL5 OOP class et Building an Automatic News Trader pour obtenir les bases techniques permettant de travailler de cette manière OO.
Traduit de l’anglais par MetaQuotes Ltd.
Article original : https://www.mql5.com/en/articles/734
Indicateurs techniques et filtres numériques
Émerveillez vos clients MQL5 avec un cocktail de technologies utilisables !
Les bases de la programmation MQL5 : Listes
Le MQL5 Wizard : Comment apprendre à un EA à ouvrir des ordres en attente à n’importe quel prix
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Vous acceptez la politique du site Web et les conditions d'utilisation