Les fonctionnalités de ChatGPT d'OpenAI dans le cadre du développement MQL4 et MQL5

Sommaire

• Introduction
• Perspectives d'utilisation de ChatGPT en MQL5
• Pièges potentiels associés à ChatGPT
• Possibilités d'utiliser ChatGPT pour résoudre des problèmes mathématiques et développer des modèles mathématiques à utiliser dans un code
• Approche correcte de la génération de code en MQL4 et MQL5
• Développer un système de trading avec ChatGPT
• Évaluation de la fonctionnalité et analyse des résultats
• Conclusion

Introduction

Commençons donc par les bases. Cette technologie est l'une des variantes de l'intelligence artificielle d'OpenAI, conçue pour aider les personnes à résoudre diverses tâches. Cet outil ressemble à une messagerie de chat classique. Cependant, à l'autre bout, il y a ce que l'on appelle une intelligence artificielle qui vous répond sous forme de texte.

Le canal de communication se limite bien sûr à du texte, mais il est suffisant pour résoudre divers problèmes ou apprendre beaucoup de nouvelles choses. Ce canal de texte est adapté à la résolution de problèmes totalement différents, tels que la programmation, les mathématiques, la physique, la chimie, sans oublier la traduction et d'autres capacités.

Ce modèle ne nous intéresse que dans le cadre du développement de systèmes de trading rentables. Je me suis intéressé à la manière d'utiliser cette technologie de manière optimale et correcte pour accélérer et faciliter le développement de systèmes de trading. Finalement, le premier à appliquer correctement une technologie pour son usage prévu réduit à la fois le coût du développement et le coût de la main-d'œuvre, ce qui lui confère des avantages concurrentiels évidents.

Perspectives d'utilisation de ChatGPT en MQL5

Examinons plus en détail les perspectives technologiques. Après une étude assez détaillée de mes propres exemples, j'ai réalisé que cette technologie n'est que le début de quelque chose de vraiment grand. Mais je peux déjà souligner les caractéristiques suivantes :

• Génération de codes MQL4 et MQL5
• Refonte et optimisation du code de travail
• Nettoyage du code
• Ajout de commentaires au code
• Correction des erreurs
• Mise en œuvre de modèles mathématiques
• Élaboration ultérieure de codes sur la base de modèles mathématiques
• Modernisation des algorithmes et des modèles mathématiques connus
• Accélération du processus de développement des Expert Advisors (EA)
• Une grande quantité d'informations

Cette liste n'est clairement exhaustive, et vous pouvez y ajouter vos propres éléments. Je pense que lorsque les gens découvrent ce type de technologie, ils commencent à se répartir en 3 sous-groupes :

1. "Maintenant nous allons faire un super algorithme"
2. Ceux qui se méfient de l'IA et s'interrogent sur son utilité
3. Une machine ne peut pas être meilleure qu'un être humain. Ce n'est qu'un battage médiatique de plus

J'ai commencé à me familiariser avec cette technologie il y a longtemps. Et, au début, j'appartenais à la troisième catégorie. Au cours des deux premiers jours où j'ai eu affaire à cette IA, je suis brusquement passé de la troisième à la première catégorie. Ensuite, un processus plus intéressant et plutôt désagréable d'ajustement de mes propres convictions a commencé, ce qui ressemble davantage à un retour à la catégorie "1,5", qui est déjà une évaluation plus réaliste de cette technologie.
Cette technologie est utile, mais pas autant qu'on pourrait le penser au premier abord. Il convient de rendre hommage aux développeurs et aux spécialistes du marketing de cette technologie, ne serait-ce que pour le fait qu'elle crée un incroyable effet "waouh" dès les deux premiers jours d'utilisation. Et cela suffit à déclencher une réaction en chaîne d'autopromotion.

Pour le comprendre, il faut beaucoup de pratique dans le traitement de l'IA. Personnellement, j'ai eu une centaine de dialogues différents avec elle, sur des sujets variés. Je peux dire que j'ai acquis suffisamment de pratique dans l'utilisation de cette technologie pour commencer à l'utiliser en MQL5. Avant de passer aux applications pratiques, je dois vous communiquer quelques informations très importantes. Pour cela nous devons regarder plus profondément sous le capot de cette technologie.

Pièges potentiels associés à ChatGPT

L'effet "waouh" que vous ressentirez au début de l'utilisation de cette technologie est dû au fait qu'il s'agit avant tout d'un modèle textuel conçu pour transformer votre question en réponse. La raison pour laquelle vous aimerez ses réponses est que les créateurs ont appris à ce modèle à mentir magnifiquement. Oui, je ne plaisante pas ! Il ment si bien que vous voudrez le croire vous-même. Et même après de nombreuses tentatives pour l'exposer, le modèle vous donnera souvent quelque chose comme ceci :

• Désolé ! Oui, vous avez raison. J'ai commis une petite erreur. J'en tiendrai compte à l'avenir. (en fait, ce n'est pas le cas. Ce n'est qu'une promesse en l'air)
• Désolé pour le malentendu, j'ai fait une erreur. Voici la version corrigée. (contenant encore plus d'erreurs)
• Vous pourriez découvrir que le modèle a fait une erreur de calcul. (en fait, le modèle ne fait aucun calcul, il se contente de trouver un chiffre approximatif quelque part).
• Vous avez détecté une erreur dans un code. (le modèle va encore chercher des excuses et essayer de vous tromper)
• Le modèle imite l'exécution d'une tâche et tente de vous convaincre qu'il a fait ce que vous aviez demandé. (en fait, il trouve quelque chose de similaire quelque part et vous le fournit. )
• Désolé ! Je n'ai pas pu vous aider. (cela se produit lorsque le modèle comprend que vous avez détecté ses mensonges ou ses erreurs).
• Le modèle ajoute beaucoup de mots excessifs dans sa réponse pour donner l'impression d'une réponse harmonieuse et cohérente. (je pense que cela est lié d'une manière ou d'une autre à l'optimisation du coût des ressources).

En bref, le modèle essaiera de se soustraire à la tâche fournie de toutes les manières possibles, tout en profitant de l'imperfection de votre "prompt". En cas d'erreur, il essaiera de se justifier de manière à ce que vous ne puissiez pas le prendre en défaut. Et s'il comprend que vous l'avez pris en défaut, il essaiera d'atténuer votre réaction négative par certaines réponses et astuces psychologiques. Je pense que l'algorithme est conçu en général pour une consommation optimale des ressources avec un niveau acceptable de satisfaction de l'utilisateur. Autrement dit, l'objectif dans ce cas n'est pas de vous donner la solution la plus qualitative au problème, mais de vous fournir une solution que vous considérez comme telle, pour des raisons possibles complètement différentes. Il s'avère que l'objectif est d'obtenir une réaction positive de la part de l'utilisateur et qu'il importe peu que la tâche soit résolue correctement. C'est ce qu'il s'efforce de faire. D'un point de vue marketing, c'est exact et, à cet égard, l'IA peut être aussi convaincante que possible.

Compte tenu de tout cela, je me suis rendu compte que pour minimiser sa liberté dans cet aspect, nous devrions tout d'abord accumuler de l'expérience dans la communication avec lui et tirer des conclusions sur le type de tâches qui ne nécessitent pas l'utilisation de cette force de persuasion, simplement parce qu'il sera facile pour l’outil de répondre à notre demande. Parce qu'elle ne sera pas efficace en termes de coût des ressources, il ne sera pas rentable pour l’IA de vous tromper. Mais il sera beaucoup plus facile de vous donner une réponse véridique.

Pour commencer à comprendre comment poser ces questions, nous devons comprendre ce qui suit :

1. La structure et le type d'une "invite" ou "prompt" ne sont pas très importants, ce sont les détails et la qualité de la question qui le sont davantage. (le modèle comprend tout et il n'est pas nécessaire de lire des guides Internet sur la manière de composer des prompts. Écrivez comme vous le souhaitez, mais sans argot.)
2. Divisez les questions ou les demandes complexes en sous-parties. (simplifier et diviser les questions pour obtenir des réponses plus précises, plus simples et plus claires).
3. Plus votre question est intelligente et ponctuelle, plus la réponse est utile.
4. L’outil ne vous donnera pas une super idée ou un algorithme. (le modèle n'a pas l'ampleur de la réflexion, de la planification et de la créativité intellectuelle. Mais au début, il semblera être capable de le créer simplement parce que, comme je l'ai dit, il ment très bien).
5. Nous devrions envisager l'utilisation de cette technologie uniquement dans le contexte de l'accélération de notre travail et de la réduction de nos coûts de main-d'œuvre.
6. Chaque nouvelle demande doit être la moins dépendante de l'ensemble du dialogue. (le modèle n'est pas en mesure de se souvenir de l'ensemble du dialogue et les anciens messages ne sont souvent pas pris en compte dans les réponses. Essayez-le et vous comprendrez ce que je veux dire).
7. Plus la question est complexe et plus elle contient de détails, plus la probabilité d'obtenir un non-sens complet est élevée. (il s'agit d'une explication du deuxième sous-paragraphe).
8. Le modèle n'a pas d'accès à Internet et génère toutes les réponses en se basant uniquement sur sa base de connaissances. (si vous lui demandez d'obtenir certaines données sur Internet, il vous donnera les anciennes données de sa base de données ou ajustera la réponse en fonction de votre contexte en la faisant passer pour une nouvelle réponse. Gardez-le à l'esprit. Le modèle fera cela simplement parce qu'il se rend compte qu'il est inutile de discuter avec vous et qu'il vaut mieux vous convaincre qu'il a tout fait).
9. ChatGPT 3.5 a été formé jusqu'en 2019. (ce qui signifie qu'il n'a aucune information sur les événements postérieurs à 2019 jusqu'à la prochaine session d’entraînement du modèle par les développeurs).
10. ChatGPT 4.0 a été formé jusqu'en 2021. (il est meilleur parce qu'il ment très peu et essaie de toujours répondre correctement. Si vous essayez de poser des questions et de comparer, vous verrez que la version 3.5 ment de manière flagrante.)

En fait, il y a beaucoup d'autres petits moments désagréables qui gâchent l'impression de cette technologie. Mais je n'écrirais pas sur ce sujet si cette technologie n'était pas utile. Tout cela revient à dire qu'il ne s'agit en aucun cas d'une intelligence artificielle. Mais si nous restons pragmatiques et que nous nous demandons si tout va si mal et quelles opérations de routine nous pouvons effectuer plus rapidement et mieux avec l'aide de cette technologie, je suis sûr que nous ne serons pas trop sévères dans notre jugement. Il ne nous reste plus qu'à réfléchir à la manière d'utiliser tout cela dans le développement de systèmes de trading.

Pour conclure cette section, je voudrais attirer votre attention sur le point le plus important et le plus fondamental que vous devez toujours garder à l'esprit :

• Vérifiez toujours les réponses de ChatGPT et en particulier les nombres, les équations et le code généré.

Grâce à mes connaissances en mathématiques et en programmation, j'ai eu l'occasion de voir de nombreux exemples de ses erreurs et de ses lacunes, et je peux dire qu'elles sont assez courantes. Cela semble insignifiant du point de vue du texte généré, mais lorsqu'il s'agit de mathématiques ou de code, même l'erreur la plus insignifiante rend toute la solution inutile. Vérifiez donc toujours vos réponses, corrigez les erreurs et attirez l'attention du modèle sur ce point. Il répond parfois correctement pendant un certain temps. Cet alinéa, entre autres, sera extrêmement utile lors de l'élaboration de vos EA.

Possibilités d'utiliser ChatGPT pour résoudre des problèmes mathématiques et développer des modèles mathématiques à utiliser dans un code

Comme ce modèle est textuel, il est facile de supposer que si nous écrivons des équations dans le bon format, il les comprendra. Il effectuera aussi des transformations mathématiques et résoudra des problèmes. Lors du développement de nombreux systèmes de trading, vous aurez besoin d'aide pour créer des équations et des expressions mathématiques. Il est possible de résoudre certains problèmes mathématiques et de les mettre en œuvre dans du code. Le format suivant est utilisé pour écrire des équations mathématiques, que ChatGPT comprend et utilise pour donner la réponse :

• LaTeX

Exemple d'utilisation du format latex pour l'écriture d'équations :

Voici le code :

E &=& mc^2\\
m &=& \frac{m_0}{\sqrt{1-\frac{v^2}{c^2}}}

Collez ceci dans n'importe quel convertisseur latex gratuit et vous obtiendrez une visualisation de données de toutes les expressions familières :

Je pense que vous savez maintenant comment interpréter visuellement les réponses du modèle au format LaTeX. Surtout, n'oubliez pas de demander au modèle de générer des équations dans ce format si la réponse contient des expressions mathématiques. Il existe également des réseaux neuronaux capables de convertir des équations en images ou dans n’importe quel autre format dont nous avons besoin. Je pense que vous trouverez ces outils si vous en avez besoin. Ma tâche est de vous montrer l'existence de cette possibilité.

Il existe des robots Telegram qui combinent de nombreux réseaux neuronaux, dont ChatGPT, et la fonction de conversion des images au format LaTeX. Si vous le souhaitez, vous pouvez trouver l'une d'entre elles dans mon profil. Ce bot a été créé par mon ami et je l’ai testé personnellement.

Vous pouvez demander à ChatGPT, par exemple, de résoudre une inégalité ou une équation, à la fois numériquement et explicitement. Vous pouvez également demander de résoudre des systèmes d'équations ou d'inégalités, ainsi que des équations différentielles ou des intégrales, ou d'effectuer toute transformation mathématique requise. Mais en tant que mathématicien, je peux dire qu'il ne le fait pas toujours de manière efficace et rationnelle et qu'il laisse parfois la tâche inachevée. Il est donc nécessaire de procéder à une double vérification.

Bien entendu, cette fonction peut être utile aux non-mathématiciens. En cas d'utilisation prolongée, vous commettrez davantage d'erreurs et votre solution sera assez irrationnelle et maladroite. Mais vous couvrirez certains des problèmes mathématiques pour votre code, étant donné que le code n'utilise généralement que des méthodes numériques, et que les mathématiques appliquées ne sont pas très compliquées. Il n'y a pas de calcul différentiel.

Approche correcte de la génération de code en MQL4 et MQL5

C'est là que les choses deviennent intéressantes. Étant donné que la taille du code de tout système de trading de qualité suffisante et plus ou moins décents est assez importante, il convient de réfléchir à la manière d'aborder le processus de génération de ce type de code. Ici, le principal obstacle est que la taille de la réponse à votre question est limitée à un certain nombre de caractères. Après de nombreuses tentatives pour générer des codes complexes et de grande taille, j'en suis venu à la conclusion que chaque sortie de code devait être suffisamment courte. Cela signifie que le code doit être affiché en plusieurs parties. Comment y parvenir ? La réponse est très simple : nous devons établir un plan pour développer un EA, un indicateur ou un script.

Le plan doit être établi en veillant à ce que chaque sous-élément constitue une sous-tâche distincte pouvant être résolue de manière indépendante. Il suffit alors de résoudre chaque sous-tâche de manière séquentielle, puis de combiner l'ensemble du code. Un autre avantage de cette approche est que chaque sous-tâche peut être finalisée séparément. Et comme chaque sous-tâche est plus simple que toutes les sous-tâches combinées ensemble, la finalisation est effectuée plus rapidement et de manière plus confortable. En plus, nous éviterons davantage d'erreurs.

En tant que développeur, il est beaucoup plus confortable pour moi de réfléchir de manière indépendante à l'architecture principale de mon EA sans permettre à l'IA d'interférer. Au lieu de cela, laissons-le mettre en œuvre des procédures distinctes dans mon EA. Toute la logique principale doit être contenue dans les procédures. Il nous suffira d'implémenter un modèle de code approximatif avec des fonctions vides, puis de lui demander d'implémenter chaque fonction individuellement. Nous pouvons également lui demander de mettre en œuvre des prototypes de fonctions ou d'autres structures.

Un autre avantage important est que vous pouvez lui demander de préparer un plan pour un EA ou un autre code, en indiquant vos exigences, et ensuite simplement mettre en œuvre son plan pièce par pièce. Il est bon d'avoir une idée approximative ou précise de ce que sera l'algorithme de votre EA et des indicateurs ou des autres approches qu'il utilisera. Mais si cette idée n'existe pas, vous pouvez d'abord lui parler et lui demander de vous aider à choisir une stratégie de trading pour votre EA. Il vous proposera quelques options. Prenons l'exemple de cette démarche.

Résumons maintenant ce qui précède et formons de brefs sous-points, symbolisant les voies possibles que nous emprunterons lorsque nous construirons un nouvel EA à partir de zéro. Tout d'abord, il existe plusieurs scénarios possibles pour démarrer :

1. Nous n'avons pas décidé de l'architecture du futur code et ne savons pas par où commencer. Nous ne savons pas non plus laquelle des approches de trading choisir.
2. Nous n'avons pas encore décidé de l'architecture du futur code et ne savons pas par où commencer, mais nous avons une idée générale du code principal et de ce que nous attendons de l'EA.
3. Nous disposons d'une architecture prête à l'emploi qui nous convient, mais nous ne savons absolument pas quelle approche de trading choisir.
4. Nous connaissons l'architecture que nous voulons utiliser et nous avons une idée claire de la future logique de trading de l'EA.

En règle générale, tout sera réduit à des constructions similaires. Ces 4 points peuvent être appliqués au schéma général de construction d'un système de trading si nous procédons comme suit :

• Si nous ne connaissons pas l'architecture (code principal ou cadre), nous devons tout d'abord la mettre en œuvre, puis mettre en œuvre tout ce qui assure le fonctionnement de ce cadre.

Cela peut signifier, par exemple, que nous pouvons demander la mise en œuvre de classes, de variables d'entrée, de champs et de prototypes de méthodes, d'interfaces, ainsi que de la principale fonctionnalité de trading de l'EA, qui utilisera les entités que nous avons décrites. En gérant correctement ChatGPT, le code peut être mis en œuvre de telle sorte qu'il ne prenne pas plus de 5 à 10% du nombre total de caractères, par exemple. Dans ce cas, nous pouvons l'implémenter rapidement et passer ensuite à l'implémentation des procédures, qui contiendront environ 90% de l'ensemble du code. Ces procédures seront mises en œuvre de la même manière simple, parce qu'elles seront nombreuses et qu'elles s'avéreront assez petites et facilement exécutables. Bien sûr, il est beaucoup plus facile de disposer d'un modèle prêt à l'emploi et de ne pas avoir à mettre tout cela en œuvre, mais cela nécessite des connaissances et de l'expérience.

Développer un système de trading avec ChatGPT

Je pense vous avoir fourni suffisamment d'informations théoriques. Il est maintenant temps de l'appliquer. Dans mon cas, j'utilise un modèle prêt à l'emploi sur lequel je base mes EA. J'ai décrit un tel modèle dans l'un des articles précédents. Sa particularité est qu'il permet de trader en parallèle de nombreux instruments, en les activant sur un seul graphique. Il comprend déjà toutes les fonctionnalités de trading nécessaires et l'architecture principale. Je vais construire un système de trading en suivant strictement les recommandations de ChatGPT. J'implémenterai moi-même la logique principale de trading de l'EA, ainsi que le composant visuel, car cela me demandera moins d'efforts.

Lorsque vous commencerez à interagir avec ChatGPT, vous réaliserez que vous dépenserez beaucoup plus d'efforts pour lui expliquer ce qui doit être fait, et que vous corrigerez ses réponses une centaine de fois lors de la mise en œuvre de certaines demandes et tâches. Au bout d'un certain temps, vous commencerez simplement à sentir quelles sont les questions qui valent la peine d'être posées et celles qui ne valent pas la peine. Vous commencerez à ne fixer que les tâches qui vous feront gagner du temps au lieu d'en perdre. La limite est assez mince, et vous devez la sentir par vous-même - il n'y a pas d'autre moyen. Tout s'apprend par la pratique. Mon approche de la conception de l'EA a été entièrement façonnée par ces considérations.

Tout d'abord, j'ai demandé de décrire la base de l'EA, c'est-à-dire son principe de fonctionnement et les méthodes ou indicateurs qu'il doit utiliser (j'ai autorisé le modèle à utiliser toute information disponible à sa discrétion). En même temps, j'ai déclaré que je n'avais besoin que de conditions logiques sous une forme lisible, que je peux mettre en œuvre moi-même dans les 4 prédicats suivants :

1. Ouverture d'une position d'achat.
2. Clôture d'une position d'achat.
3. Ouverture d'une position de vente.
4. Clôture d'une position de vente.

Pour mettre en œuvre ces prédicats, le modèle m'a proposé la logique conditionnelle suivante :

1. Le prix actuel est au-dessus de l'EMA, la différence entre le prix actuel et l'EMA est inférieure à ATR * ratio, et le RSI est inférieur à 30.
2. Le prix actuel est en dessous de la SMA, ou le prix actuel est au-dessus de la bande supérieure de l'indicateur des Bandes de Bollinger.
3. Le prix actuel est en dessous de l'EMA, la différence entre le prix actuel et l'EMA est inférieure à ATR * ratio, et le RSI est supérieur à 70.
4. Le prix actuel est au-dessus de la SMA, ou le prix actuel est en dessous de la bande inférieure de l'indicateur des Bandes de Bollinger.

Il est évident que ces conditions booléennes renvoient "true" en cas de succès et "false" en cas d'échec. Ces valeurs de signal sont tout à fait suffisantes pour trader avec des ordres de marché. Je souhaite ici attirer votre attention sur la possibilité évidente de moderniser cette logique. Pour cela, nous pouvons procéder comme suit :

• [K1] — zone inférieure du RSI
• [K2 = 100 - K1] — zone supérieure du RSI

Ces expressions peuvent être utilisées pour améliorer la flexibilité de l'algorithme, ce qui aura par la suite un effet positif sur l'efficacité de l'optimisation de l'EA :

1. Le prix actuel est au-dessus de l'EMA, la différence entre le prix actuel et l'EMA est inférieure à ATR * ratio, et le RSI est inférieur à K1.
2. Le prix actuel est en dessous de la SMA ou le prix actuel est au-dessus de la bande supérieure de l'indicateur des Bandes de Bollinger.
3. Le prix actuel est en dessous de l'EMA, la différence entre le prix actuel et l'EMA est inférieure à ATR * ratio, et le RSI est supérieur à K2.
4. le prix actuel est au-dessus de la SMA ou le prix actuel est en dessous de la bande inférieure de l'indicateur des Bandes de Bollinger

J'ai donné cet exemple parce qu'il ne faut pas hésiter à étendre le modèle s'il est évident que la solution en question n'est qu'un cas particulier d'un algorithme différent et plus étendu. Même si vous ne savez pas ce qu'une telle extension peut vous apporter, en faisant cela vous augmentez au moins la flexibilité de votre algorithme. Et donc la probabilité d'un réglage plus fin et, par conséquent, d'une amélioration possible de son efficacité.

Compte tenu des conditions à mettre en œuvre, nous aurons besoin de l'une des deux options suivantes pour mettre en œuvre les indicateurs suivants :

1. SMA — moyenne mobile simple (une ligne)
2. EMA — moyenne mobile exponentielle (une ligne)
3. Bandes de Bollinger - Bandes de Bollinger (ensemble de trois lignes)
4. RSI — indice de force relative (une ligne dans une fenêtre séparée)
5. ATR — average true range (une ligne dans une fenêtre séparée)

Les indicateurs peuvent être mis en œuvre à l'aide de fonctions MQL5 prédéfinies. Mais je n'aime pas cette approche, car le code mis en œuvre sera plus difficile à convertir en version MQL4. Il me sera aussi plus difficile de l'intégrer, par exemple, dans mes projets dans d'autres langages, ce que je fais très souvent. J'ai depuis longtemps pris l'habitude de faire les choses le plus simplement possible et en pensant à un usage futur. Je pense que c'est une très bonne habitude.

Le deuxième point important est que, en règle générale, ces indicateurs entraînent des calculs et des fonctionnalités inutiles et redondants. Il est également impossible d'affiner ces indicateurs, car leurs fonctions sont figées dans le code. Pour apporter des modifications, vous devrez de toute façon créer votre propre version de l'indicateur. Je pense qu'il est évident qu'il est préférable d'avoir une implémentation personnalisée à l'intérieur d'un EA ou d'un script. Pour mettre en œuvre de tels indicateurs, j'ai trouvé l'astuce suivante :

1. Création de tableaux pour stocker les valeurs des lignes d'indicateurs (limitées aux N dernières barres).
2. Mise en œuvre du décalage des valeurs d'un tableau lorsqu'une nouvelle barre apparaît.
3. Réinitialisation des tableaux des valeurs des indicateurs en cas d'erreurs ou de déconnexion prolongée.
4. Implémentation du calcul de la valeur de l'indicateur pour la dernière barre lors de sa fermeture.

Dans cette approche, les trois premiers paragraphes créent des blocs de tableaux communs et des fonctions qui permettent d'effectuer les actions énumérées. Voyons ce que cela donne en prenant l'exemple de notre tâche. Commençons par le premier point :

   double SMA1Values[]; // Array for storing SMA values
   double EMAValues[];  // Array for storing EMA values (exponential)
   double RSIValues[];  // Array for storing RSI values
   
   double BollingerBandsUpperValues[];  // Array for storing BollingerBands values, upper
   double BollingerBandsMiddleValues[]; // Array for storing BollingerBands values, middle
   double BollingerBandsLowerValues[];  // Array for storing BollingerBands values, lower
   
   double ATRValues[];// array for storing Average True Range values

Ces tableaux sont initialisés au début de l'EA avec les limites de longueur données :

   //Prepare indicator arrays
   void PrepareArrays()
   {
      ArrayResize(SMA1Values, LastBars);
      ArrayResize(EMAValues, LastBars);
      ArrayResize(RSIValues, LastBars);
      ArrayResize(BollingerBandsUpperValues, LastBars);
      ArrayResize(BollingerBandsMiddleValues, LastBars);
      ArrayResize(BollingerBandsLowerValues, LastBars);
      ArrayResize(ATRValues, LastBars);
   }

Contrairement aux indicateurs conventionnels, nous n'avons pas besoin d'intégrer toutes les valeurs précédentes avec nous pour cette stratégie. C'est un avantage indéniable. J'aime ce paradigme de mise en œuvre, car il garantit la simplicité du code et l'équivalence des valeurs de départ de l'indicateur et de celles obtenues à l'aide des valeurs précédentes. Voyons maintenant à quoi ressemble le décalage de valeur :

   //shift of indicator values
   void ShiftValues()
   {
      int shift = 1;
      for (int i = LastBars - 1; i >= shift; i--)
      {
         SMA1Values[i] = SMA1Values[i - shift];
         EMAValues[i] = EMAValues[i - shift];
         RSIValues[i] = RSIValues[i - shift];
         BollingerBandsUpperValues[i] = BollingerBandsUpperValues[i - shift];
         BollingerBandsMiddleValues[i] = BollingerBandsMiddleValues[i - shift];
         BollingerBandsLowerValues[i] = BollingerBandsLowerValues[i - shift];
         ATRValues[i] = ATRValues[i - shift];
      }
   }

Comme vous pouvez le constater, tout est extrêmement simple. Il en va de même pour l’effacement des tableaux :

   //reset all indicator arrays if connection fails [can also be used when initializing an EA]
   void EraseValues()
   {
      for (int i = 0; i < LastBars; i++)
      {
         SMA1Values[i] = -1.0;
         EMAValues[i] = -1.0;
         RSIValues[i] = -1.0;
         BollingerBandsUpperValues[i] = -1.0;
         BollingerBandsMiddleValues[i] = -1.0;
         BollingerBandsLowerValues[i] = -1.0;
         ATRValues[i] = -1.0;
      }
   }

Je pense que l'utilisation de cette fonctionnalité est assez claire. Passons maintenant à la mise en œuvre des indicateurs eux-mêmes. Pour cela, j'ai demandé à ChatGPT d'implémenter la fonction appropriée, qui conviendrait en fonction de mon paradigme de construction de code. J'ai commencé avec l'indicateur SMA :

   //1 Function that calculates the indicator value to bar "1"
   double calculateMA(int PeriodMA,int Shift=0)
   {
      int barIndex=Shift+1;//bar index SMA is calculated for (with a shift)
      int StartIndex=barIndex + PeriodMA-1;//starting bar index for calculating SMA
      if (StartIndex >= LastBars) return -1.0; // Check for the availability of the bars for calculating SMA (if not valid, then the value is -1)
      double sum = 0.0;

      for (int i = StartIndex; i >= barIndex; i--)
      {
         sum += Charts[chartindex].CloseI[i];
      }
      LastUpdateDateTime=TimeCurrent();
      return sum / PeriodMA;
   }

Comme vous pouvez le constater, la fonction s'est avérée très simple et très courte. Au départ, l'apparence de cette fonction était un peu différente. Lors de la première génération, j'ai trouvé beaucoup d'erreurs, par exemple liées au fait qu'il ne comprenait pas le sens de la numérotation des barres par rapport au temps, etc. Mais après quelques manipulations, j'ai corrigé tout cela et j'ai ajouté le paramètre Shift, qui ne figurait pas dans l'implémentation originale. Après avoir apporté quelques améliorations visuelles, j'ai demandé à ce que les autres indicateurs soient mis en œuvre de la même manière. Par la suite, il y a eu moins d'erreurs dans sa mise en œuvre. Je viens d'envoyer les demandes suivantes pour la mise en œuvre d'une fonction similaire pour un autre indicateur, avec des exemples des implémentations précédentes dans le contexte de la question. Cela a permis de gagner beaucoup de temps. Examinons maintenant les implémentations de tous les indicateurs restants. Commençons par l'EMA :

   //2 Function that calculates the value of the exponential moving average to bar "1"
   double calculateEMA(int PeriodEMA,double Flatness=2.0,int Shift=0)
   {
      int barIndex = Shift+1; // bar index EMA is calculated for (with a shift)
      int StartIndex=barIndex + PeriodEMA-1;//index of the starting bar for calculating the first SMA, for starting the recurrent calculation of EMA
      if (StartIndex >= LastBars) return -1.0; // Check for the availability of the bars for calculating EMA (if not valid, then the value is -1)
   
      double sum = 0.0;
      double multiplier = Flatness / (PeriodEMA + 1); // Weight multiplier 
      double prevEMA;
   
      // Calculate the initial value for the EMA (the first value is considered as a normal SMA) 
      for (int i = StartIndex; i >= barIndex; i--)
      {
         sum += Charts[chartindex].CloseI[i];
      }
      prevEMA = sum / PeriodEMA;//this is the starting value for the bar (StartIndex-1)
   
      // Apply the EMA formula for the remaining values 
      for (int i = StartIndex; i >= barIndex; i--)
      {
         prevEMA = (Charts[chartindex].CloseI[i] - prevEMA) * multiplier + prevEMA;
      }
   
      LastUpdateDateTime = TimeCurrent();
      return prevEMA;
   }

Lors de nos recherches sur les générations ChatGPT, nous devons nous tourner vers diverses ressources Internet pour comprendre quel indicateur est basé sur quelle idée. Cela nous rend plus compétents. C'est particulièrement évident dans le cas de l'EMA. Si nous examinons attentivement le code, nous verrons qu'il ne diffère pas beaucoup de l'implémentation plus simple de la SMA et qu'il ressemble plutôt à un ajout à la moyenne mobile habituelle. Il n'y a pas d'exposant ici, bien que pour une raison quelconque il soit présent dans le nom de l'indicateur. Le suivant est l'indicateur RSI :

   //3 Function for calculating RSI to bar "1"
   double calculateRSI(int PeriodRSI,int Shift=0)
   {
       int barIndex = Shift+1; // bar index RSI is calculated for (with a shift)
       int StartIndex = barIndex + PeriodRSI - 1; // starting bar index for calculating RSI
       if (StartIndex >= LastBars) return -1.0; // Check for the availability of the bars for calculating RSI (if not valid, then the value is -1)
   
       double avgGain = 0.0;
       double avgLoss = 0.0;
       double change;
   
       // Calculate initial values for avgGain and avgLoss
       for (int i = StartIndex; i > barIndex; i--)
       {
           change = Charts[chartindex].CloseI[i]-Charts[chartindex].OpenI[i];
           if (change > 0)
           {
               avgGain += change;
           }
           else if (change < 0)
           {
               avgLoss -= change;
           }
       }
   
       avgGain /= PeriodRSI;
       avgLoss /= PeriodRSI;
   
       // RSI calculation
       double RS = 0.0;
       if (avgLoss != 0)
       {
           RS = avgGain / avgLoss;
       }
   
       double RSI = 100 - (100 / (1 + RS));
   
       LastUpdateDateTime = TimeCurrent();
       return RSI;
   }

Nous devons maintenant procéder de la même manière pour l'indicateur des Bandes de Bollinger. Cette procédure doit renvoyer les valeurs de 3 courbes, qui peuvent être placées dans la structure préparée au préalable :

   //structure to return all three bollinger band lines
   struct BollingerBands 
   {
       double upper;
       double middle;
       double lower;
   };

Maintenant, après avoir ajouté cette structure au contexte de la question, nous pouvons lui demander d'implémenter la fonction, en tenant compte du fait qu'elle doit renvoyer le type BollingerBands. Le modèle s'acquittera sans problème de cette tâche :

   //4 Function for calculating the Bollinger Bands of the indicator 
   BollingerBands calculateBollingerBands(int PeriodBB, double DeviationBB,int Shift=0) 
   {
       int barIndex = Shift+1; // bar index Bollinger Bands is calculated for (with a shift)
       int StartIndex = barIndex + PeriodBB - 1; // index of the starting bar for calculating the first SMA, for starting the recurrent calculation of EMA
       BollingerBands rez;
       rez.lower=-1.0;
       rez.middle=-1.0;
       rez.upper=-1.0;
       if (StartIndex >= LastBars) return rez; // Check for the availability of the bars for calculating BB (if not valid, then the value is -1)
   
       double sum = 0.0;
       double prevBB;
       double sumSquares = 0.0;
   
       // Calculate the initial value for BB (the first value is considered as a normal SMA)
       for (int i = StartIndex; i >= barIndex; i--) {
           double closePrice = Charts[chartindex].CloseI[i];
           sum += closePrice;
       }
       prevBB = sum / PeriodBB; //this is the starting value for the bar (StartIndex-1)
   
       // Calculation of standard deviation
       for (int i = StartIndex; i >= barIndex; i--) {
           double closePrice = Charts[chartindex].CloseI[i];
           sumSquares += pow(closePrice - prevBB, 2);
       }
       double standardDeviation = sqrt(sumSquares / PeriodBB);
   
       // Calculate Bollinger Bands
       double upperBand = prevEMA + DeviationBB * standardDeviation;
       double lowerBand = prevEMA - DeviationBB * standardDeviation;
   
       rez.upper = upperBand;
       rez.middle = prevEMA;
       rez.lower = lowerBand;
   
       LastUpdateDateTime = TimeCurrent();
       return rez;
   }

Il reste maintenant à mettre en œuvre la version de la fonction de calcul de l'ATR :

   //5 Function for calculating Average True Range (Relative)
   double calculateRelativeATR(int PeriodATR,int Shift=0)
   {
       int barIndex = Shift+1; // bar index ATR is calculated for (with a shift)
       int StartIndex = barIndex + PeriodATR - 1; // starting bar index for calculating the first ATR
       if (StartIndex >= LastBars) return -1.0; // Check for the availability of the bars for calculating ATR and True Range (if not valid, then the value is -1)
   
       double sumPrice=0.0;
       double sumTrueRange = 0.0;
       double ATR;
   
       // Calculating True Range for bars and the sum of values for calculating the first ATR
       for (int i = StartIndex; i >= barIndex; i--)
       {
           sumPrice+=Charts[chartindex].HighI[i]+Charts[chartindex].LowI[i]+Charts[chartindex].CloseI[i]+Charts[chartindex].OpenI[i];//added by me 
           double high = Charts[chartindex].HighI[i];
           double low = Charts[chartindex].LowI[i];
           double trueRange = high - low;
           sumTrueRange += trueRange;
       }
   
       // ATR calculation
       //ATR = sumTrueRange / PeriodATR; - conventional calculation
       ATR = 100.0 * (sumTrueRange / PeriodATR)/(sumPrice/(PeriodATR*4.0));//calculation of relative ATR in %
   
       LastUpdateDateTime = TimeCurrent();
       return ATR;
   }

Faites attention à la ligne commentée à la fin. J'ai légèrement modifié cet indicateur pour qu'il opère des valeurs relatives. Cela est nécessaire pour ne pas avoir à définir nos propres pondérations pour chaque instrument de trading. Cela se fera donc automatiquement sur la base du prix actuel. Cela permettra une optimisation multi-devises plus efficace. Nous en aurons besoin pour prouver que même un algorithme aussi simple, s'il est utilisé correctement, peut nous donner une période à terme petite mais suffisante pour le trading. En combinaison avec d'autres méthodes d'efficacité, ce trade peut être rendu tout à fait acceptable, même au niveau actuellement autorisé par l'EA.

J'ai implémenté les prédicats moi-même. C'était très facile. Prenons l'un d'entre eux, le premier par exemple :

   //to open buy positions
   bool bBuy()
      {
      //determine if an open position is already present
      bool ord;
      ulong ticket;
      bool bOpened=false;
      for ( int i=0; i<PositionsTotal(); i++ )
         {
         ticket=PositionGetTicket(i);
         ord=PositionSelectByTicket(ticket);
         if ( ord && PositionGetInteger(POSITION_MAGIC) == MagicF)
            {
            bOpened=true;
            return false;
            }
         }
         
      if (!bOpened && EMAValues[1] > 0.0)//only if nothing is open and the indicator has been calculated 
         {
         //K - control ratio
         //RSIPercentBorder - control RSI
         double Val1=Charts[chartindex].CloseI[1]-EMAValues[1];
         double Val2=ATRValues[1]*(1.0/K);
         if (Val1 > 0 && Val1 < Val2 && RSIValues[1] < RSIPercentBorder) return true;         
         } 
      return false;
      }

La condition préalable à l'ouverture d'une position de vente est similaire, à quelques exceptions près. Le prédicat de clôture est encore plus simple :

   //to close a buy position
   bool bCloseBuy()
      {
      if (SMA1Values[1] > 0.0)
         {
         if (Charts[chartindex].CloseI[1] < SMA1Values[1] || Charts[chartindex].CloseI[1] > BollingerBandsUpperValues[1] )
            {
            return true;
            }
         }
      return false;   
      }

Tout cela fonctionnera de manière très simple :

   IndicatorDataRecalculate();//recalculate indicators

   if ( bCloseBuy() )
      {
         CloseBuyF();
      }
   if ( bCloseSell() )
      {
         CloseSellF();  
      }
   if ( bBuy() )
      {
         BuyF();
      }
   if ( bSell() )
      {
         SellF();
      } 

Je pense que c'est aussi simple que possible et qu'il n'est pas nécessaire de le compliquer davantage. Tout ce code doit être exécuté lorsqu'une nouvelle barre apparaît. J'ai implémenté la visualisation des indicateurs séparément. La seule chose que je n'aime pas, est que les indicateurs comme l’ATR et le RSI sont conçus pour être dessinés dans une fenêtre séparée. J'ai créé ma version de leurs rendus de manière à ce qu'ils soient également liés au prix, étant donné qu'une fenêtre séparée ne peut pas être créée artificiellement et que, franchement, ils ne sont pas vraiment nécessaires. Pour ce faire, j'ai créé un certain paradigme pour dessiner les indicateurs de fenêtre.

1. La saisie de la valeur de contrôle du pourcentage permet de créer 3 canaux à partir d'un seul.
2. Détermination des valeurs maximales (Max) et minimales (Min) de l'indicateur pour l'ensemble du tableau des valeurs stockées.
3. Calcul du delta du canal donné (Delta = Max - Min).
4. Calcul du canal supérieur des valeurs augmentées (HighBorder = Max - Delta * Pourcentage / 100).
5. Calcul du canal inférieur des valeurs augmentées (LowBorder = Min + Delta * Pourcentage / 100).
6. Le canal central a déjà été défini, puisque les canaux supérieur et inférieur ont été définis.

Si la valeur actuelle de l'indicateur se situe dans l'un des canaux, ses points acquièrent la couleur correspondant au canal. Tout est simple. C'est ainsi que nous pouvons lier des valeurs aux barres du graphique et, par exemple, changer leur couleur en conséquence, ou simplement créer des objets liés à la barre et ayant la couleur correspondante. Comme beaucoup l'ont probablement remarqué, je me suis inspiré de l'indicateur RSI, car cette structure particulière est généralement utilisée pour le trading. Ces zones sont appelées zones de surachat et de survente.

Je pense que ce code n'est pas très important ici car il a le moins de rapport avec la mise en œuvre de notre tâche. Mais il aide à corriger d'éventuelles erreurs et à apporter des améliorations. Si vous le souhaitez, vous pouvez même mettre en œuvre ce rendu à l'aide de ChatGPT. Mais je pense qu'il vaut la peine de montrer comment il fonctionne :

Ici, tout est fait aussi simplement que possible avec la seule aide du type d'objet Line. Si, lors de la création d'une ligne, les points de départ et d'arrivée de la ligne sont liés à la même heure et au même prix, la ligne se transforme en point. En ajustant l'épaisseur de la ligne, nous ajustons le poids du point correspondant. Il ne s'agit là que de quelques astuces de vie que j'utilise depuis très longtemps.

Évaluation de la fonctionnalité et analyse des résultats

Bien que ChatGPT considère cet algorithme comme optimal, nous ne savons pas sur quoi ces décisions sont basées. Un bon backtest ou un trading réel peut servir de mesure de l'efficacité. J'espère que tout le monde comprend que le trading réel doit être précédé d'un réglage optimal, ce qui peut être fait à l'aide de l'optimiseur de MetaTrader 5. Étant donné que ce terminal offre la possibilité d'une optimisation multidevises et compte tenu des capacités de mon modèle, qui utilise pleinement l'efficacité de cet outil, nous pouvons en toute sécurité optimiser l'EA pour l'ensemble des "28" paires de devises. Il n'est peut-être pas utile de les énumérer. Mais il convient de noter les avantages évidents de cette approche :

1. Recherche automatique de modèles multidevises
2. Les modèles multidevises ont plus de poids et s'adaptent mieux aux changements du marché.
3. Il s'agit en fait d'un plus grand nombre de transactions, puisque chaque instrument de trading apporte quelque chose qui lui est propre
4. Gain de temps (vous ne devez pas optimiser chaque outil individuellement)

Il y a bien sûr des inconvénients. Dans ce cas, le plus important est l'impossibilité de procéder à un réglage fin pour chaque instrument. Bien entendu, ce problème peut être résolu en introduisant des fonctionnalités supplémentaires, mais ce n'est pas le sujet de cet article. Mais il ne suffit pas non plus d'effectuer cette optimisation. Il est également important de sélectionner correctement les résultats parmi l'ensemble des possibilités qu'elle offre. J'ai choisi le meilleur :

Comme vous pouvez le voir, j'ai optimisé de "2018" à "2023" en utilisant la période "H4", et j'ai laissé les six mois de "2023" pour l'avenir. Comme nous pouvons le voir, malgré la courbe de profit loin d'être parfaite dans la section d'optimisation, nous avons obtenu quelques mois supplémentaires de trading rentable, ce qui signifie que la stratégie n'est pas dénuée de sens et qu'elle a le potentiel d'être utilisée avec succès pour le trading. De nombreux systèmes de trading optimisables ne s'approcheraient probablement même pas de ce résultat. Il est parfois possible de tester des systèmes incroyablement cool en termes de code sans pour autant obtenir de tels résultats.

J'ajouterais beaucoup plus à cet algorithme. Je considère que c'est un terrain de jeu. Mais il convient de préciser que ce n'est pas du tout cela qui importe, mais le potentiel d'expansion de l'EA qui en résulte. Ce n'est pas l'algorithme proposé qui joue un rôle ici, mais votre compétence et votre créativité. Vous devrez posséder des qualités importantes pour réussir votre intégration dans le processus de développement de MQL5 :

• Compétences en programmation (obligatoire)
• Compétences en mathématiques (souhaitable)
• La pensée en bloc
• Capacité à simplifier les tâches et à les décomposer en étapes distinctes
• Comprendre que ChatGPT n'est qu'un outil, et qu'il est donc inutile de le blâmer pour les choses qui ne fonctionnent pas (c'est à vous de réparer ce qui ne fonctionne pas).
• Interprétation correcte des résultats de trading obtenus
• La prise de conscience que le modèle fait de toute façon des erreurs, mais cela ne devrait pas vous gêner (l'essentiel est que vous ayez réduit le coût du travail de développement).
• Développer votre propre structure d'application (ce n'est pas nécessaire, bien sûr, vous pouvez utiliser mon approche)
• ChatGPT est votre compagnon dont la force dépend de vous. Plus vous êtes patient, intelligent et ingénieux, plus ce compagnon est efficace.

Vous disposez d'un outil que vous pouvez utiliser ou non, à votre discrétion, mais je peux affirmer que cet outil m'a été très utile dans de nombreux domaines, y compris la programmation.

Conclusion

En fait, il n'est pas nécessaire d'adhérer à mon modèle d'utilisation de cet outil. J'ai essayé beaucoup de choses avec lui, et je peux dire que les possibilités sont presque illimitées. Bien sûr, avant de réussir, vous devrez certainement consacrer du temps et des efforts, comme moi.

Mais je vous conseille tout de même d'essayer cet outil et de ne pas perdre votre temps. Au moins, l'utilisation de ChatGPT vous permettra d'adopter la bonne attitude à l'égard de l'intelligence artificielle. Il est potentiellement possible d'intégrer cette technologie dans presque toutes les chaînes de développement. Je suis persuadé que ce n'est qu'un début et que des changements sont à venir. Je vous conseille de commencer à vous familiariser avec cet outil dès que possible et d'essayer de l'appliquer à un éventail de tâches le plus large possible.