Trading Quantitatif - page 33
Vous manquez des opportunités de trading :
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Inscription
Se connecter
Vous acceptez la politique du site Web et les conditions d'utilisation
Si vous n'avez pas de compte, veuillez vous inscrire
Deep Learning Trading Strategy du début à la production en utilisant TensorFlow 2.0 et TFX
Deep Learning Trading Strategy du début à la production en utilisant TensorFlow 2.0 et TFX
Je suis ravi de me présenter sous le nom de Denis et je vous souhaite chaleureusement la bienvenue sur ClosetoAlgotrading, votre chaîne de référence pour tout ce qui concerne le trading algorithmique.
Cela fait un certain temps que l'idée m'est venue à l'esprit : créer une stratégie de trading en utilisant uniquement la puissance de l'apprentissage en profondeur. Le concept s'articule autour du développement d'un réseau neuronal capable d'identifier de manière autonome les paramètres nécessaires à l'exécution de transactions rentables. Pour me lancer dans ce voyage passionnant, j'ai décidé de mener une expérience en direct, qui, je l'espère, captivera également votre intérêt. Dans les prochains épisodes, je vous guiderai à travers chaque étape de la mise en œuvre d'une approche de science des données pour élaborer une stratégie de trading robuste, des premières étapes à la production finale.
Mon objectif est de couvrir toutes les étapes intermédiaires de manière exhaustive, y compris la préparation des données, les tests rigoureux et au-delà. À l'avenir, j'utiliserai TensorFlow 2.0 et j'explorerai les possibilités offertes par le pipeline tfx. J'ai l'intention d'éviter les calculs ou les règles complexes, en m'appuyant plutôt sur la puissance de l'apprentissage en profondeur pour déterminer si nous pouvons créer une entreprise vraiment rentable. Si cette idée résonne en vous, je vous encourage à vous abonner à la chaîne et à me rejoindre dans cette expédition captivante. Ensemble, nous naviguerons dans les méandres du trading algorithmique et nous nous efforcerons de libérer son potentiel caché.
Pour ceux qui sont curieux d'approfondir l'approche de la science des données, une simple recherche sur Google donnera diverses ressources élucidant le sujet. Parmi les résultats, vous trouverez peut-être des articles informatifs et des représentations visuelles qui décrivent les étapes à suivre pour suivre cette méthodologie.
Le premier bloc crucial de notre parcours est la phase de compréhension de l'entreprise. À ce stade, nous devons définir méticuleusement nos objectifs et établir des indicateurs de performance clés (KPI) qui servent de valeurs mesurables pour évaluer l'efficacité de notre stratégie dans l'atteinte de ces objectifs. Pour se lancer dans cette phase, il est crucial de consacrer du temps à bien comprendre les subtilités de votre domaine d'activité spécifique. En acquérant une compréhension approfondie de votre cible, vous pouvez procéder avec clarté et concentration. Il est impératif de discerner si vous visez à prédire des résultats spécifiques ou à classer des phénomènes particuliers.
Pour déterminer la nature de notre tâche, nous devons chercher des réponses à des questions fondamentales. Si notre enquête tourne autour de "Combien" ou "Combien", nous avons affaire à une tâche de régression. D'un autre côté, si nous nous interrogeons sur « quelle catégorie », nous nous aventurons dans le domaine de la classification, et ainsi de suite. Une fois que nous avons saisi le type de tâche que nous cherchons à accomplir, il est essentiel de définir les paramètres qui signifieront le succès. Dans notre cas, ces mesures pourraient inclure le retour sur investissement (ROI) et la précision. Après tout, notre objectif ultime est de tirer profit du marché, ce qui nécessite une bonne compréhension des mouvements de prix futurs.
Prévoir efficacement le mouvement futur des prix implique non seulement de déterminer la direction, mais également d'identifier le niveau de prix précis et le moment où il sera atteint. Cependant, le simple fait de connaître la direction est insuffisant. Nous avons besoin du niveau de prix exact et du moment où il sera atteint. Pour éviter des délais d'attente interminables pour notre prix cible, nous pouvons définir un prix cible minimum attendu et un délai d'attente maximum. En d'autres termes, nous cherchons à déterminer la direction des mouvements de prix futurs, ressemblant à une tâche de classification où le prix peut augmenter, baisser ou rester au même niveau.
Pour mesurer initialement la performance de notre modèle dans la prédiction de la direction, nous pouvons utiliser la précision de la classification. Cette métrique quantifie le nombre de prédictions correctes divisé par le nombre total de prédictions, multiplié par 100 pour l'exprimer en pourcentage. Maintenant, qu'en est-il de notre niveau de prix cible ? Pour notre stratégie de trading, nous pouvons définir le niveau de profit en pourcentage de notre capital investi. De plus, nous devons déterminer notre tolérance au risque en établissant un niveau stop-loss comme risque maximum acceptable pour une seule transaction. Nos niveaux de profit et d'arrêt servent de valeurs de retour sur investissement pour chaque transaction. Par exemple, supposons que nous achetons des actions à 100 $ et que nous les vendons lorsqu'elles atteignent 105 $. Ce mouvement de prix de 5 % rapporterait un rendement de 5 % sur notre investissement. Avec nos niveaux de sortie définis, englobant à la fois les prises de bénéfices et les stop-loss, nous devons résoudre le problème du temps. Nous ne souhaitons pas attendre indéfiniment que le prix atteigne les niveaux souhaités.
Par conséquent, nous établissons une période de détention maximale, mais en utilisant le volume échangé au lieu d'un laps de temps fixe. La justification de ce choix deviendra plus claire dans le prochain épisode, où je développerai la préparation des données.
Pour résumer notre approche jusqu'à présent : nous développons une stratégie intrajournalière qui utilise le take profit, le stop loss et une période de détention maximale pour la clôture des positions. Pour initier des transactions, nous entraînerons un modèle de classification capable de prédire la direction future du prix : vers le haut, vers le bas ou à plat. Dans un premier temps, nous utiliserons la précision comme mesure de l'efficacité de notre modèle. Avec cette fondation en place, nous concluons notre discussion pour aujourd'hui. Nous avons défini nos objectifs, nos cibles et nos indicateurs de performance. Dans l'épisode suivant, nous approfondirons nos données, en préparant des ensembles de données et des étiquettes pour une analyse et un développement plus approfondis.
Ne manquez pas le prochain épisode de notre voyage. D'ici là, prenez soin de vous, et j'attends avec impatience notre prochaine rencontre.
Deep Learning Trading Strategy du début à la production. Deuxieme PARTIE.
Deep Learning Trading Strategy du début à la production. Deuxieme PARTIE.
Je suis ravi de vous accueillir dans la deuxième partie de notre voyage captivant dans la création d'un système commercial. Dans la vidéo précédente, nous avons discuté de nos objectifs, et aujourd'hui nous allons nous concentrer sur la préparation et l'étiquetage de notre ensemble de données. Alors plongeons dedans !
Pour commencer, j'ai défini un ensemble de fonctions qui nous aideront dans la préparation de notre ensemble de données. Avant tout, nous devons charger nos données. Pour la démonstration d'aujourd'hui, j'utiliserai un petit ensemble de données pour garder le temps d'exécution du code gérable. Comme vous pouvez le voir, l'ensemble de données comprend des données de tick, y compris des informations telles que l'heure, le prix, le volume, l'offre et la demande. Aux fins de cette démonstration, j'utiliserai des données sur une période d'un an. Commençons par examiner quelques statistiques pour mieux comprendre les caractéristiques de l'ensemble de données. L'un des aspects clés que nous observons est le prix minimum et maximum, qui oscille autour de 100 $. Ceci est avantageux car il permet un calcul facile des pourcentages de profit.
De plus, j'ai introduit un paramètre crucial dans l'ensemble de données : la taille de la propagation. Le spread est calculé comme la différence entre les prix Ask et Bid. Pourquoi la taille de la propagation est-elle importante ? Pour illustrer, considérons un exemple où le prix Bid est de 100 $ et le prix Ask est de 101 $. Dans ce cas, l'écart est égal à 1 $. Si nous devions acheter et vendre immédiatement l'action, nous perdrions toujours le spread, qui, dans cet exemple, s'élève à 1 $. Pour mieux comprendre la taille de la propagation, j'ai calculé la moyenne de la propagation sur tous les jours pour chaque seconde. Comme le montre le graphique, l'écart varie généralement entre 1 et 2 cents, avec des occurrences occasionnelles d'écarts légèrement plus grands. Sur la base de cette analyse, nous pouvons décider d'exécuter des transactions uniquement si le spread est inférieur à 3 cents.
Fait intéressant, le graphique montre que les écarts les plus importants ont tendance à se produire dans les premières minutes après l'ouverture du marché. Par conséquent, il est prudent de sauter les 10 à 15 premières minutes lors de la mise en œuvre d'une stratégie intrajournalière. Maintenant que nous avons défini la période et examiné l'écart, nous pouvons procéder à la génération d'étiquettes pour notre modèle, qui prédiront la direction du mouvement des prix. Comment génère-t-on ces étiquettes ? Comme mentionné dans la vidéo précédente, puisque nous manquons de déclencheurs pour ouvrir une position, nous devons générer des étiquettes pour chaque barre en fonction du rendement attendu.
Pour ce faire, nous utiliserons la méthode de la fenêtre, où les étiquettes sont générées lorsque les prix franchissent les barrières de la fenêtre. Voici comment cela fonctionne : nous définissons une fenêtre de longueur n barres et définissons des barrières de fenêtre supérieure et inférieure en fonction de notre rendement attendu en pourcentage. Lorsque nous faisons glisser cette fenêtre sur toutes les barres, avec une taille de pas d'une barre, si le prix sort de la fenêtre, la première barre de la fenêtre recevra l'étiquette. Avant de procéder à la génération d'étiquettes, établissons les paramètres de la fenêtre. Bien que l'idée sous-jacente soit simple, la sélection de la taille de fenêtre et des niveaux de barrière optimaux peut être difficile. Personnellement, j'ai passé beaucoup de temps à m'attaquer à ce problème et je n'ai pas encore trouvé de solution définitive.
Pour relever ce défi, je vais calculer la volatilité historique sur la journée et l'ensemble de données. Par exemple, le graphique présenté illustre la variation de prix sur chaque tick au cours d'une journée, ainsi que la volatilité correspondante. De plus, nous pouvons évaluer la volatilité sur l'ensemble de l'ensemble de données. Comme indiqué, la volatilité moyenne n'est que de 0,003 %, ce qui équivaut à environ 30 cents du prix actuel. Cependant, je n'ai pas l'intention d'utiliser une fenêtre qui s'étend sur toute la journée. Pour déterminer la longueur de la fenêtre, j'ai tenté de générer 100 fenêtres avec des tailles aléatoires et j'ai évalué la volatilité moyenne dans chaque fenêtre. Le graphique résultant représente la volatilité moyenne pour des fenêtres de différentes longueurs. En sélectionnant une taille de fenêtre de 50 barres par exemple, on peut anticiper une volatilité de l'ordre de 0,001%.
Cette valeur de volatilité devient utile pour définir notre rendement minimum attendu et calculer la taille de notre prix stop-loss. Avec ces informations en main, nous pouvons procéder à la génération de barres de volume à partir de nos données de ticks. L'utilisation de barres au lieu de graduations nous permet de calculer plus facilement la longueur de la fenêtre, car une barre contient généralement un volume similaire, garantissant des conditions stables. Pour générer une barre de volume, nous parcourons les ticks et accumulons le volume jusqu'à ce qu'il dépasse ou soit égal à un volume cible prédéfini (par exemple, 1000). Les ticks rencontrés lors de cette phase d'accumulation représentent une barre de volume. Générons des barres de volume pour une seule journée à titre d'exemple. Comme illustré, nous obtenons 179 barres pour le jour sélectionné.
Par conséquent, le graphique des prix se compose désormais de ces barres de volume. De plus, nous pouvons calculer le pourcentage de variation dans chaque barre et la volatilité quotidienne en utilisant le cours de clôture. Cependant, je n'ai pas l'intention d'utiliser une fenêtre couvrant toute la journée. Pour déterminer la longueur de la fenêtre, j'ai utilisé la volatilité moyenne et des fenêtres générées aléatoirement pour l'ensemble de données. Le graphique résultant présente la volatilité de la fenêtre sur l'ensemble de données.
Maintenant que nous avons terminé ces étapes préparatoires, nous sommes prêts à générer les étiquettes. Pour cette démonstration, j'ai choisi une taille de fenêtre de 50 barres et un rendement attendu de 0,003 %, ce qui correspond à environ 30 cents sur la base du prix moyen. Une fois le processus d'étiquetage terminé, nous pouvons trouver plusieurs étiquettes similaires, appelées étiquettes croisées. Pour éviter d'avoir des étiquettes identiques pour des événements différents, nous ne retiendrons que les étiquettes avec la distance la plus proche entre la première barre de la fenêtre et la barre où le prix franchit la barrière de la fenêtre. Lors de l'inspection, nous constatons que nous avons environ 700 étiquettes, réparties uniformément entre les trois catégories (haut, bas et plat).
Maintenant, sauvegardons notre jeu de données. Nous allons créer deux fichiers : un contenant l'ensemble de données de la barre de volume et un autre fichier contenant les informations sur les ticks pour chaque barre. Ce dernier peut s'avérer utile dans notre modèle, il vaut donc la peine de le préserver. Sur ce, je vais interrompre notre discussion pour aujourd'hui. Je pense que nous avons parcouru beaucoup de chemin, et pour ceux qui souhaitent approfondir l'étiquetage des données, je recommande d'explorer les chapitres 3 et 4 du livre de Marcos Lopez de Prado, qui fournissent des informations précieuses.
Notre prochaine étape impliquera l'ingénierie des fonctionnalités et l'exécution de tout via le pipeline tfx. J'espère créer bientôt un nouvel épisode pour partager des informations plus intrigantes.
D'ici là, prenez soin de vous, et j'attends avec impatience notre prochaine vidéo.
Deep Learning Trading Strategy du début à la production. Partie III. Canalisation TFX.
Deep Learning Trading Strategy du début à la production. Partie III. Canalisation TFX.
Je suis ravi de vous accueillir à nouveau dans un autre épisode de "Close to AlgoTrading" avec moi, Denis. Nous avons repris notre expérience après les vacances du Nouvel An, et bien que les progrès aient été lents, nous continuons d'avancer. Dans la vidéo d'aujourd'hui, nous allons examiner de plus près nos données étiquetées et explorer le pipeline TFX. Alors, plongeons dedans !
Dans la vidéo précédente, nous avons réussi à créer des étiquettes pour nos données, mais j'ai oublié de vous montrer comment elles apparaissent sur un graphique. Pour rappel rapide, nous avons stocké toutes les données dans une nouvelle trame de données. Allons-y et lisons cette trame de données.
Dans notre cadre de données, la colonne 'dir' contient les étiquettes, tandis que la colonne 'cross_idx' représente le numéro de tick lorsque le prix traverse notre fenêtre définie. Pour représenter visuellement les événements de position d'ouverture et de fermeture basés sur ces colonnes, j'ai créé une fonction simple. Sur le graphique, un événement de position ouverte est indiqué par un triangle rempli, tandis qu'un événement de position fermée est représenté par un triangle vide.
Comme vous pouvez le voir, la plupart des événements ouverts se produisent à des points maximum ou minimum locaux dans le tableau des prix. À l'avenir, nous continuerons à travailler avec un petit ensemble de données, similaire à celui que nous avons utilisé précédemment. De plus, je diviserai l'ensemble de données en ensembles de données d'entraînement, d'évaluation et de test.
Maintenant que nous comprenons mieux nos étiquettes, passons à l'étape suivante et commençons à travailler avec le pipeline TFX. Pour ceux qui ne connaissent pas TFX, il signifie Tensorflow Extended, et c'est un cadre puissant conçu spécifiquement pour les tâches d'apprentissage automatique évolutives et hautes performances. Le pipeline TFX se compose d'une séquence de composants qui exécutent différentes étapes du flux de travail d'apprentissage automatique, telles que l'ingestion de données, la modélisation, la formation, l'inférence de service et la gestion du déploiement.
Pour nous familiariser avec TFX, je vous recommande d'explorer la page Web officielle de Tensorflow TFX, qui fournit des informations détaillées sur ses composants et sur la manière dont ils sont interconnectés. Vous trouverez les liens pertinents dans la description de la vidéo.
Comme je suis également nouveau sur TFX, nous apprendrons ensemble dans chaque épisode. Aujourd'hui, nous allons nous concentrer sur les quatre premiers composants du pipeline. Présentons-les brièvement :
ExampleGen : ce composant d'entrée initial du pipeline ingère l'ensemble de données d'entrée et le divise éventuellement en différents sous-ensembles. Dans notre cas, il ne prend pas directement en charge les fractionnements de séries chronologiques personnalisés. Je divise donc manuellement les données en ensembles de données d'entraînement, d'évaluation et de test.
StatisticsGen : ce composant calcule les statistiques de l'ensemble de données, fournissant des informations sur la distribution des données, l'écart type, les valeurs manquantes, etc. Il génère des artefacts statistiques pour une analyse plus approfondie.
SchemaGen : après avoir examiné les statistiques, le composant SchemaGen crée un schéma de données basé sur les caractéristiques de données observées. Le schéma décrit la structure et les propriétés de nos données.
ExampleValidator : ce composant vérifie les anomalies et les valeurs manquantes dans l'ensemble de données, en utilisant les statistiques et le schéma comme références. Il aide à identifier les modèles de données inattendus ou incohérents.
Pour m'assurer que nous sommes sur la bonne voie, j'utiliserai l'exemple de taxi de Chicago fourni par l'équipe Tensorflow comme modèle. Cet exemple illustre le flux de travail de bout en bout, y compris l'analyse des données, la validation, la transformation, la formation du modèle et la diffusion.
Maintenant, reportons notre attention sur nos propres données. Après avoir importé les modules requis et défini les variables nécessaires pour les dossiers de données d'entrée et de sortie, nous pouvons tenter de charger nos données dans le pipeline TFX. Le dossier d'entrée contient des sous-dossiers pour les ensembles de données d'évaluation, d'entraînement et de test.
En utilisant le composant ExampleGen, nous devrions pouvoir charger facilement nos données dans le pipeline. Cependant, il semble que ExampleGen ne prend pas directement en charge les divisions de séries chronologiques personnalisées. Par défaut, il divise les données en ensembles d'apprentissage et d'évaluation uniquement. Heureusement, nous pouvons fractionner manuellement les données et configurer notre propre configuration de fractionnement d'entrée, garantissant ainsi un mappage un à un entre les fractionnements d'entrée et de sortie.
Par conséquent, le composant ExampleGen produit deux artefacts : un pour l'ensemble de données d'apprentissage et un autre pour l'ensemble de données d'évaluation. Examinons les trois premiers éléments de notre ensemble d'entraînement pour vérifier qu'il correspond à notre ensemble de données d'origine. Ensuite, nous transmettons la sortie du composant ExampleGen au composant StatisticsGen. Ce composant génère des artefacts statistiques pour les ensembles de données d'entraînement et d'évaluation. Avec une seule commande, nous pouvons représenter visuellement les statistiques de l'ensemble de données, y compris la distribution des données, l'écart type, les valeurs manquantes, etc.
Ici, nous pouvons observer les statistiques de l'ensemble de données de formation, obtenant ainsi des informations précieuses sur les caractéristiques des données. Nous pouvons également examiner le même ensemble de statistiques pour l'ensemble d'évaluation. Sur la base des statistiques, nous remarquons que seulement 2 % de nos étiquettes sont non nulles, ce qui suggère que nos événements d'entrée pour les transactions rentables pourraient être des valeurs aberrantes. Cela pourrait poser un défi à l'avenir en raison du déséquilibre entre les classes.
Ensuite, nous générons automatiquement le schéma de données à l'aide du composant SchemaGen. Ce schéma est dérivé des statistiques observées, mais nous pourrions également définir notre propre description des données si vous le souhaitez. La sortie est un schéma qui fournit une description complète de la structure et des propriétés de nos données. Enfin, nous atteignons le composant ExampleValidator, qui valide les données en fonction des statistiques et du schéma générés. Il vérifie toute anomalie ou incohérence dans l'ensemble de données. Par exemple, dans l'exemple du taxi de Chicago, la caractéristique « _company » avait une valeur de chaîne inattendue. Nous pouvons utiliser l'ExampleValidator pour détecter de tels problèmes dans notre propre ensemble de données.
Dans notre cas, heureusement, nous ne rencontrons aucune anomalie ou incohérence dans notre jeu de données. C'est un signe positif, indiquant que nos données sont relativement propres et alignées sur nos attentes. Eh bien, cela conclut notre introduction rapide à TFX. Dans le prochain épisode, nous approfondirons les composants TFX restants et explorerons comment transformer nos données et former notre modèle.
Merci d'avoir regardé, et j'ai hâte de vous voir dans la prochaine vidéo!
Partie IV. Deep Learning Trading Strategy du début à la production. Canalisation TFX 2.
Partie IV. Deep Learning Trading Strategy du début à la production. Canalisation TFX 2.
Bienvenue dans un autre épisode de "Close to Algotrading". Je suis Denis, et aujourd'hui nous allons continuer à explorer le pipeline TFX dans le cadre de la construction de notre stratégie de trading.
Dans la vidéo précédente, nous avons couvert les quatre premiers composants du pipeline TFX : ExampleGen, StatisticsGen, SchemaGen et ExampleValidator. Ces composants ont jeté les bases de notre pipeline, garantissant la validation et la cohérence des données.
Passons maintenant aux composants restants : Transformer, Trainer, Evaluator, ModelValidator et Pusher. Ces composants nous permettront de transformer nos données, d'entraîner notre modèle, d'évaluer ses performances, de valider le modèle par rapport à une ligne de base et enfin, de pousser le modèle validé vers un environnement de production.
Mais avant de poursuivre, permettez-moi d'aborder quelques points importants. Bien que le pipeline TFX offre un cadre puissant, il convient de noter qu'il peut encore contenir des bogues et que certains composants peuvent être en cours de construction. Cependant, abordons chaque étape avec soin et discutons des limitations en cours de route. Dans la vidéo précédente, nous avons validé avec succès nos données, et maintenant il est temps de passer à l'étape de transformation. Pour cela, nous utiliserons le composant Transformer fourni par TFX.
Le composant Transform est responsable de l'exécution des transformations de données et de l'ingénierie des fonctionnalités qui sont cohérentes pour la formation et le service. Cela signifie que nous pouvons utiliser la même fonction de transformation de données pour former le modèle et l'utiliser en production. Cette fonctionnalité est l'une des principales raisons pour lesquelles j'ai commencé à explorer TFX en premier lieu.
Pour commencer le processus de transformation, nous devons créer quelques fichiers Python. Le premier fichier contiendra nos constantes, telles qu'une liste de caractéristiques numériques et d'étiquettes. Le deuxième fichier contiendra une fonction de prétraitement (preprocessing_fn), qui est une fonction de rappel utilisée par tf.Transform pour prétraiter les données d'entrée. Dans cette fonction, nous allons définir les étapes de transformation des données et de construction des fonctionnalités. Pour l'instant, concentrons-nous sur la transformation de toutes les entités d'entrée numériques en scores z et sur la modification des valeurs d'étiquette de -1, 0 et 1 à 0, 1 et 2, respectivement. Cette transformation d'étiquette est nécessaire, car l'estimateur TensorFlow attend des valeurs positives.
Il est important de noter que dans la version actuelle de TFX, seuls les estimateurs TensorFlow sont pris en charge. Si vous préférez utiliser un modèle Keras, vous devrez le convertir en estimateur à l'aide de l'API model_to_estimator. Bien que la version 0.21 de TFX prétende prendre en charge les modèles Keras pour le composant Trainer, j'ai rencontré quelques problèmes avec sa fonctionnalité de contexte interactif. Espérons que l'équipe TFX résoudra ces problèmes bientôt et fournira un outil stable et entièrement fonctionnel.
Passons maintenant à la transformation des données. Comme vous pouvez le constater, le composant Transform attend les paramètres suivants en entrée : les exemples générés, le schéma de données et le chemin d'accès au fichier contenant la fonction preprocessing_fn. Une fois la transformation terminée, nous pouvons passer à la création et à la formation de notre modèle. Le volet Formateur se chargera de former le modèle selon le cahier des charges que nous définissons.
Dans le fichier Python contenant notre modèle et nos fonctions d'entrée, nous définissons une fonction trainer_fn qui sera appelée par le composant Trainer. Cette fonction doit renvoyer un dictionnaire avec les éléments suivants :
Dans ce fichier, nous définissons la fonction _input_fn, qui génère les caractéristiques d'entrée et les étiquettes pour la formation et l'évaluation. Nous avons également des fonctions supplémentaires, telles que _example_serving_receiver_fn, qui construit les entrées de service, et _eval_input_receiver_fn, qui prépare les entrées nécessaires pour TensorFlow Model Analysis (TFMA).
Pour créer notre estimateur, nous définissons une fonction build_estimator. Dans cette fonction, nous configurons le jeu de caractéristiques d'entrée et créons notre estimateur. Il convient de mentionner que j'ai utilisé DNNLinearCombinedEstimator car DNNClassifier et DNNEstimator provoquaient des erreurs liées au passage des fonctionnalités de TensorFlow 1. Je pense que ce n'est pas le cas puisque nous utilisons les méthodes TensorFlow 2. Malheureusement, je n'ai pas trouvé de solution à ce problème. Cependant, l'estimateur linéaire semble bien fonctionner.
Maintenant que notre modèle est défini, nous pouvons procéder à sa formation à l'aide du composant Trainer. Comme vous pouvez le voir, le composant Trainer attend un module_file qui contient la fonction trainer_fn, ainsi que d'autres paramètres tels que transformer_examples, le schéma de données, le graphique de transformation et les arguments d'entraînement et d'évaluation. Pour l'instant, nous avons seulement précisé le nombre d'étapes pour la formation et l'évaluation. Une fois la formation du modèle terminée, nous pouvons passer à l'analyse du modèle à l'aide de TensorFlow Model Analysis (TFMA). Avant de continuer, assurez-vous d'avoir installé TFMA en suivant le lien fourni. TFMA nous permet d'effectuer des analyses sur notre modèle, soit sur l'ensemble de données, soit sur des tranches de caractéristiques spécifiques. Dans ce cas, nous effectuerons une analyse sur trois tranches : l'ensemble de données complet, l'étiquette et deux caractéristiques spécifiques.
En analysant l'ensemble de données complet, nous observons une précision remarquable de 98 %. Cependant, lors de l'examen des performances du modèle en fonction des étiquettes, nous remarquons qu'il prédit systématiquement l'étiquette 0. Ce résultat était attendu en raison des étiquettes déséquilibrées et de l'absence de fonctionnalités utiles dans notre modèle. Néanmoins, TFMA fournit un moyen pratique d'évaluer les performances du modèle.
À l'avenir, nous avons le composant ModelValidator, qui nous aide à valider nos modèles exportés. Il compare les nouveaux modèles à une ligne de base (telle que le modèle actuellement utilisé) et détermine s'ils répondent aux critères prédéfinis. Cette validation comprend l'évaluation des modèles sur un ensemble de données d'évaluation et le calcul de métriques telles que l'AUC et la perte. Si les métriques du nouveau modèle satisfont aux critères spécifiés par le développeur par rapport à la ligne de base, le modèle est considéré comme "assez bon" et marqué comme tel.
Enfin, nous avons le composant Pusher, qui vérifie si le modèle a passé la validation. Si le modèle répond aux critères de validation, il est poussé vers une destination de fichier spécifiée. Cette étape garantit que seuls les modèles validés sont déployés dans l'environnement de production.
Pour conclure notre pipeline, nous pouvons exporter tous les composants dans un pipeline Apache Beam. Nous pouvons ensuite regrouper tous les fichiers nécessaires dans une archive zip. En décompressant les fichiers de l'archive dans notre répertoire de travail sur le serveur, nous pouvons exécuter le pipeline. Une fois l'exécution terminée, nous disposerons d'un modèle entraîné prêt à être utilisé avec TensorFlow Serving. Si vous souhaitez apprendre à démarrer et à utiliser TensorFlow Serving à partir d'un conteneur Docker, vous pouvez trouver un didacticiel vidéo sur ma chaîne.
Bien que nous ayons couvert beaucoup de terrain dans cette série, il est important de noter que la version actuelle de TFX a encore certaines limitations. En fonction de vos besoins spécifiques, il peut être nécessaire d'implémenter un pipeline qui repose uniquement sur la fonction de transformation avec un modèle Keras. Cependant, j'espère que cette exploration de TFX a été informative et bénéfique.
Dans la vidéo suivante, nous reviendrons sur notre objectif principal de développer une stratégie de trading. Restez à l'écoute pour ça! N'oubliez pas de commenter, de vous abonner et de liker cette vidéo. Merci d'avoir regardé, et à la prochaine !
Partie V. GIGO. Deep Learning Trading Strategy du début à la production.
Partie V. GIGO. Deep Learning Trading Strategy du début à la production.
Bienvenue dans un autre épisode de "Close to Algotrading". Je m'appelle Denis et je suis ici pour partager mes expériences et mes échecs dans le développement d'un système d'apprentissage en profondeur.
J'ai consacré beaucoup de temps à la mise en œuvre de l'ensemble du système à l'aide de TensorFlow, mais je dois admettre que je suis assez déçu de la qualité de la bibliothèque. Bien que j'apprécie le concept, la documentation fournie par TensorFlow a été une source de frustration. Il semble que même les esprits brillants avec leurs doctorats peinent à rédiger une documentation bien structurée. Même s'il s'est amélioré par rapport au passé, il reste déroutant sur plusieurs points.
Cependant, la documentation n'est qu'un problème mineur par rapport au plus gros problème que j'ai rencontré. De nombreuses fonctions ne fonctionnent tout simplement pas comme prévu lorsque j'ai essayé de les utiliser, et même les exemples officiels ne fonctionnent parfois pas correctement. Cela m'a amené à me demander si j'avais peut-être manqué certains points essentiels de ce cadre. Mais revenons au sujet principal de cette vidéo : mes échecs. Comme vous vous en souvenez peut-être, j'ai décidé de générer des étiquettes pour le mouvement des prix en fonction d'un pourcentage spécifié. La majorité de ces étiquettes se sont avérées être des minimums ou des maximums locaux dans les données.
Après avoir effectué un traitement et une préparation simples des données, j'ai créé un réseau LSTM simple et l'ai mis à l'épreuve. Mes attentes n'étaient pas exceptionnellement élevées, mais les résultats ont été vraiment décevants. Comme vous pouvez le voir dans le visuel ci-joint, le réseau n'a rien appris de significatif.
Maintenant, il est important de se rappeler qu'un réseau de neurones n'est pas destiné à faire des miracles. Il est peut-être temps de réévaluer notre approche. Les événements que nous essayons de prédire ne représentent que 2 % de l'ensemble des données. Ces événements peuvent être considérés comme des valeurs aberrantes, et notre réseau simple a du mal à les distinguer du reste des données. De plus, il existe une forte probabilité que ces événements ne soient pas liés et aient des causes distinctes, ce qui rend difficile la construction d'un modèle qui les prédit avec précision.
Compte tenu de ces défis, il est devenu évident que nous devons nous concentrer sur une meilleure compréhension des données et sur l'identification des caractéristiques ayant un pouvoir prédictif. Dans cet esprit, j'ai décidé de revoir une stratégie de moyenne mobile simple. Dans notre approche initiale, nous ne comprenions pas clairement pourquoi nous devrions prendre position. Cependant, nous avons maintenant une stratégie pour ouvrir des positions. Bien qu'elle ne soit pas parfaite, c'est une stratégie largement utilisée dont nous pouvons tirer parti. J'ai ajouté deux moyennes mobiles et un indicateur RSI (Relative Strength Index) à notre ensemble de données et collecté tous les événements où les moyennes mobiles se sont croisées. Cela nous a permis d'estimer les directions du mouvement des prix.
Ensuite, j'ai créé des méta-étiquettes en utilisant la même méthode d'étiquetage qu'auparavant, mais cette fois, je n'ai étiqueté que les barres où les moyennes mobiles se croisaient. Il y a une différence importante ici : puisque nous connaissons déjà le sens de la position (long ou court), la signification de nos étiquettes sera différente. Une étiquette de 1 indique un profit, -1 représente une perte et 255 est attribué pour les autres cas. Avec l'ensemble de données et les étiquettes mis à jour, j'ai formé un modèle LSTM simple et obtenu une courbe ROC (Receiver Operating Characteristic) parfaite. La courbe ROC montre les performances d'un modèle de classification à différents seuils de classification. La valeur AUC (Area Under the Curve) de la courbe ROC nous aide à évaluer dans quelle mesure le modèle distingue les classes.
Cependant, lors de l'examen des prédictions du modèle, j'ai remarqué qu'il prédisait systématiquement la classe 0. Ce résultat s'est produit parce que, encore une fois, j'ai utilisé l'ensemble des données au lieu des seuls événements pertinents. Notre ensemble de données est resté déséquilibré et les caractéristiques manquaient de capacité prédictive. Les courbes ROC ne sont pas idéales pour les ensembles de données déséquilibrés, car elles peuvent masquer les mauvaises performances du modèle dans la prédiction d'autres classes.
Pour remédier au déséquilibre des données, j'ai procédé à des ajustements et me suis concentré uniquement sur les données pertinentes pour les événements ouverts. Malheureusement, même après ces modifications, mon modèle n'a pas réussi à présenter un pouvoir prédictif. Il produit les mêmes résultats qu'un modèle aléatoire. J'ai également essayé un modèle simple d'anticipation, qui a montré des résultats légèrement meilleurs mais toujours insatisfaisants. En conclusion, comme vous pouvez le voir, il n'y a pas de magie dans le deep learning si vous alimentez votre modèle avec des données de mauvaise qualité. Le principe de "Garbage in, garbage out" s'applique dans ce contexte. De plus, lorsqu'il s'agit d'ensembles de données très déséquilibrés et dépourvus de caractéristiques à fort pouvoir prédictif, un modèle de classification aura tendance à prédire la classe qui constitue la majorité de l'ensemble de données.
Comme je l'ai mentionné plus tôt, il est crucial pour nous de comprendre nos données et d'identifier les processus qui peuvent nous aider à trouver un moyen de battre le marché.
Cela conclut l'épisode d'aujourd'hui. J'espère que vous l'avez trouvé perspicace et instructif. Prenez soin de vous, restez chez vous et restez en bonne santé.
Partie VI. Apprentissage par renforcement. Deep Learning Trading Strategy du début à la production
Partie VI. Apprentissage par renforcement. Deep Learning Trading Strategy du début à la production
Je suis Denis, et bienvenue dans un autre épisode de "Close to Alga Trading". Dans nos épisodes précédents, nous avons travaillé à l'élaboration d'une stratégie de trading rentable en utilisant l'apprentissage en profondeur. Récapitulons nos progrès jusqu'à présent.
Nous avons commencé par observer les conditions du marché à la recherche d'inefficacités. Une fois identifiés, nous avons créé des règles simples et préparé les données pour nos modèles d'apprentissage en profondeur. Cependant, lors de la mise en œuvre de notre approche directe, nous avons découvert qu'elle ne donnait pas les résultats escomptés. Cela nous a amenés à réaliser que nous devons repenser notre approche et envisager des stratégies alternatives.
Dans l'épisode d'aujourd'hui, nous allons explorer une nouvelle direction : l'apprentissage par renforcement. L'apprentissage par renforcement a remporté un succès significatif dans divers domaines, dépassant les performances humaines dans des jeux comme les échecs, Dota et Go. Il est également utilisé dans la robotique de contrôle et les voitures autonomes. Alors, pourquoi ne pas l'appliquer au trading ? Bien que je ne puisse pas garantir son succès, c'est une voie intrigante à explorer.
Pour commencer, plongeons dans une brève introduction à l'apprentissage par renforcement et familiarisons-nous avec les définitions clés.
L'apprentissage par renforcement peut être décrit comme un apprentissage par essais et erreurs pour résoudre des problèmes de contrôle optimal. En termes plus simples, il s'agit de trouver la meilleure action à entreprendre dans un état d'environnement donné pour maximiser une récompense numérique finale. Pour mieux comprendre ce concept, visualisons-le avec une simple analogie.
Imaginez un trader assis devant un écran, achetant et vendant des actions. Ici, le trader représente l'agent, tandis que le prix du graphique et le courtier forment l'environnement. L'agent observe l'état actuel de l'environnement et prend des mesures, telles que l'achat d'une action. En retour, l'agent reçoit une récompense, qui pourrait être les frais du courtier. À mesure que l'environnement change, l'agent peut acheter plus d'actions, vendre ou ne rien faire. À la fin de la journée de négociation, l'agent reçoit une récompense finale, qui peut être positive ou négative. Le but de l'agent est de maximiser cette récompense finale.
En apprentissage par renforcement, notre objectif est de concevoir des agents capables d'apprendre en interagissant avec un environnement. Maintenant, familiarisons-nous avec les principales définitions que nous rencontrerons tout au long de notre parcours.
Agent : L'algorithme qui prend des décisions, exécute des actions, observe l'environnement, reçoit des commentaires et vise à maximiser la récompense.
Environnement : Le monde dans lequel l'agent réside. Il englobe toutes les données disponibles pour que notre agent puisse prendre des décisions.
État : la configuration de l'environnement détectée par l'agent.
Récompense : les commentaires que l'agent reçoit après avoir effectué une action. C'est une valeur que l'agent cherche à maximiser. Surtout, dans l'apprentissage par renforcement, la récompense ne signifie pas nécessairement de l'argent ou un trophée physique. Il s'agit simplement d'une valeur numérique qui peut également être négative, et notre objectif est de maximiser cette valeur.
Action : Tout ce que l'agent est capable de faire dans l'environnement donné. Pour simplifier, considérons trois actions : acheter, vendre ou ne rien faire.
Épisode : Une exécution complète de l'ensemble de la tâche.
Ce sont les principales définitions que nous utiliserons tout au long de notre voyage. Il y a d'autres termes importants que nous couvrirons dans les prochaines vidéos.
Avec cette introduction à l'apprentissage par renforcement, nous allons continuer à en apprendre davantage sur l'environnement et créer notre propre environnement à l'aide de TensorFlow dans la vidéo suivante.
Merci de vous joindre à moi aujourd'hui, et j'ai hâte d'explorer davantage l'apprentissage par renforcement avec vous. À bientôt!
Part VII. Reinforcement Learning. Trading Environment.
Part VII. Reinforcement Learning. Trading Environment.
I'm Denis, and you're watching "Close to AlgoTrading." In our last episode, we provided a brief introduction to reinforcement learning. Today, we'll dive into creating a simple trading environment for our agent. Let's explore the details.
First, we need to consider what the trading environment represents. Is it solely based on price data, or should we incorporate additional factors like the complete order book, news, or even rumors from Twitter? This decision will shape the complexity of our environment.
Next, we need to determine the actions our agent can perform. Should it be limited to "buy" and "sell" actions, or can it also skip certain steps? Defining the action space is crucial for our agent's decision-making process.
Now, let's discuss the target and how we'll define rewards. In the real world, the trading environment has a continuous state space. However, for simplicity, let's keep the environment as straightforward as possible, enabling us to understand its inner workings and implementation.
To start, instead of using real price data, we'll generate a random walk process consisting of only 20 values. These simulated daily prices will serve as our input. The episode will begin from the middle of this price sequence, meaning the initial state will include the 10 historical prices. The remaining invisible prices will be filled with zeros. With each step, a new price will be added to the array. The episode will conclude when all 20 prices become visible to the agent. Therefore, we have a total of 10 steps until the episode's completion.
In addition to the price data, the state will include information about our open position. Let's represent the position using one-hot encoding: [0,0] for no open position, [1,0] for a long position, and [0,1] for a short position.
Considering typical trading actions, we'll include "buy" and "sell" for cases when no position is open. However, if there's already an open position, the agent can only choose to skip or close the position. Thus, in this scenario, the "sell" or "buy" action is equivalent to "skip."
Our agent's goal is to maximize profit and loss (PnL) over the 10-day period. Therefore, we'll define the reward as the daily PnL.
With a clear understanding of our environment's structure and behavior, we can now proceed to the implementation stage. As mentioned earlier, we'll utilize the TensorFlow (tf-agent) framework. The tf-agent team has provided a comprehensive guide on developing a suitable environment for tf-agent, which I recommend checking out for a deeper understanding of the code.
To create our environment, we'll start by inheriting the PyEnvironment class, as it defines the interface that all Python environments must implement. Within the Init function, we'll initialize variables, set initial states, and most importantly, specify the action and observation specifications. In our case, the action space will consist of four different actions, with minimum and maximum values set to 0 and 3, respectively. The observation specification will describe the environment state, with the price starting from 0 and no maximum limit. The data type for prices will be float. Returning the action and observation specifications is crucial for seamless integration with tf-agent.
The next significant function to implement is reset. This function will reset the environment to its initial state. Ensuring the correct implementation of this function is vital for the environment's proper functioning.
Now, let's discuss the most critical function: step. The step function receives an action as an input parameter and is responsible for managing the environment's state transitions. In this function, we'll handle all possible actions and calculate the PnL (reward). The function returns a time_step, which consists of the observation (the part of the environment state the agent can observe to choose its actions at the next step), the reward (the agent's learning objective), step_type (indicating whether this time step is the first, intermediate, or last in a sequence), and discount.
In the step function, we have two different return scenarios: one for intermediate steps and another for the last step in the episode.
After creating the environment, it's essential to validate it to identify and fix any bugs. The util package provides a function called validate_py_environment, which can be used for this purpose. Additionally, checking the environment specifications will help ensure everything is functioning as expected.
With our environment ready for use, it's a good idea to test it with different actions to debug and validate its behavior.
I conducted some tests using a simple DQN tf-agent, and here are the results. After 20,000 steps, the agent demonstrated acceptable performance. However, keep in mind that we only had one time series for the agent to learn, making it relatively straightforward. If we introduce a second time series and run 20,000 steps, the results may not be as promising. But with around 100,000 steps, the agent's performance improved significantly.
Partie VIII. Stratégie de trading d'apprentissage par renforcement. DQN : QNetwork, QRNNNetwork
Partie VIII. Stratégie de trading d'apprentissage par renforcement. DQN : QNetwork, QRNNNetwork
Bonjour, je m'appelle Denis et vous regardez "Close to AlgoTrading". Dans cette vidéo, nous fournirons une brève mise à jour sur notre environnement précédent pour l'agent d'apprentissage par renforcement. Nous donnerons également une brève description de Q-Learning et de l'agent DQN. Nous procéderons ensuite à la mise en œuvre des principales étapes d'apprentissage d'un agent rDQN à partir de la bibliothèque tf-agents et discuterons des résultats du test.
Pour commencer, revenons sur l'environnement de trading que nous avons créé dans la vidéo précédente. Dans cet environnement, nous avons utilisé des données synthétiques générées. Cependant, dans cette version mise à jour, notre environnement recevra une trame de données avec des données historiques comme paramètres d'entrée. L'observation_spec pour l'environnement est un dictionnaire avec deux clés : "Price" et "Pos." La clé "Prix" contient 20 éléments avec des données d'ouverture, de clôture, de haut, de bas et de volume. La touche "Pos" contient des informations sur notre position ouverte.
Au début de chaque épisode, nous sélectionnons au hasard une tranche de 20 prix parmi nos données. Ce changement permet à notre agent d'apprentissage par renforcement d'apprendre à partir de données historiques réelles.
Passons à autre chose, discutons de Q-Learning et du concept de Q-Table. Le Q-Learning consiste à attribuer une valeur Q à chaque paire de (état, action). Cette table, connue sous le nom de Q-Table, est utilisée par l'agent pour sélectionner les actions avec la valeur Q maximale dans l'état actuel. L'agent explore l'environnement, reçoit des récompenses et met à jour les valeurs Q en fonction des récompenses observées.
Pour mettre à jour les valeurs Q, nous utilisons une formule qui implique l'ancienne valeur Q et la future valeur Q. Nous calculons la valeur Q future en recherchant la valeur Q maximale pour l'état suivant dans notre Q-Table. Avec la valeur Q future obtenue, nous mettons à jour la valeur Q associée à la paire de départ (état, action).
Cependant, dans notre cas, le marché financier a un espace d'état très large, ce qui rend peu pratique l'utilisation d'une Q-Table. Pour surmonter ce défi, nous pouvons utiliser un réseau neuronal profond pour prédire les valeurs Q pour un état donné. Cette approche, connue sous le nom d'agent DQN (Deep Q-Network agent), utilise un Q-Network, où les valeurs Q sont mises à jour en minimisant la perte par rétropropagation. La fonction de perte utilisée dans l'agent DQN est donnée par une équation spécifique.
Maintenant que nous avons une bonne compréhension de Q-Learning et de l'agent DQN, passons à la mise en œuvre des principales étapes d'apprentissage de l'agent rDQN à l'aide de la bibliothèque tf-agents.
L'algorithme d'entraînement global suit ces étapes :
La création de l'environnement est une tâche simple. Nous intégrons notre environnement commercial dans l'environnement TFPyEnvironment, qui permet une intégration transparente avec les agents tf.
Ensuite, nous créons un Q-Network pour l'agent DQN. La bibliothèque tf-agents fournit une classe Q-Network que nous pouvons utiliser pour définir notre Q-network. Nous définissons un réseau Q simple avec une couche cachée entièrement connectée composée de 40 neurones. Comme notre observation est un dictionnaire, nous définissons également une couche de prétraitement simple pour celle-ci.
Une fois le Q-Network créé, nous procédons à la création d'un agent DQN. Nous instancions la classe tf_agents.agents.dqn.dqn_agent, en passant notre Q-network en paramètre. Nous définissons également l'optimiseur et la fonction de perte pour entraîner le modèle.
Pour former l'agent, nous avons besoin des données de l'environnement. Nous collectons ces données à l'aide d'une politique, et pour cette étape, nous pouvons sélectionner aléatoirement les actions. L'agent DQN a deux stratégies : agent.policy, qui est utilisé pour l'évaluation et le déploiement, et agent.collect_policy, qui est utilisé pour la collecte de données.
La collecte de données implique de prendre l'état actuel, de sélectionner une action, de recevoir l'état et la récompense suivants, et de stocker ces informations dans une mémoire tampon. Nous collectons plusieurs étapes ou épisodes, formant des trajectoires. La bibliothèque tf-agents fournit un pilote appelé DynamicEpisodeDriver, qui collecte les étapes jusqu'à la fin d'un épisode. Le pilote met à jour les observateurs, y compris un tampon de réponse.
Pour stocker les données, nous pouvons utiliser le TFUniformReplayBuffer couramment utilisé de la bibliothèque tf-agents. Nous définissons les spécifications des éléments de données que le tampon stockera, la taille du lot et la longueur maximale de chaque segment de lot.
Une fois l'étape de collecte des données terminée, nous pouvons former notre agent. L'agent a besoin d'accéder au tampon de relecture. Nous créons un pipeline tf.data.Dataset pour fournir des données à l'agent. Chaque ligne du tampon de relecture stocke une seule trajectoire, mais l'agent DQN a besoin à la fois des observations actuelles et suivantes pour calculer la perte. Par conséquent, nous définissons le paramètre num_steps sur 2, ce qui permet au pipeline de l'ensemble de données d'échantillonner deux lignes pour chaque élément du lot.
À ce stade, nous avons tout en place pour former deux agents DQN sur les mêmes données et évaluer leurs performances. Un agent utilise un simple Q-Network, tandis que l'autre utilise un QRNNNetwork. Les deux agents sont formés à l'aide de 200 jours de données de prix historiques.
Après 700 étapes d'apprentissage, nous observons que l'agent Q-Network simple n'a pas appris grand-chose et affiche le plus souvent un rendement moyen négatif. Cependant, l'agent QRNNNetwork affiche principalement des rendements moyens positifs. Ce résultat est conforme aux attentes, car l'agent RNN peut capturer certaines dynamiques dans les données et apprendre plus rapidement.
Bien que cette expérience simple offre un certain espoir d'utiliser l'apprentissage par renforcement pour créer un agent rentable, il existe encore d'autres mesures à prendre en compte pour évaluer les performances de l'agent. Nous les explorerons dans une future vidéo.
Merci d'avoir regardé, et je vous verrai dans le prochain épisode.
Partie IX Stratégie de trading d'apprentissage par renforcement. DQN : test de la stratégie de négociation basée sur la politique de l'agent
Partie IX Stratégie de trading d'apprentissage par renforcement. DQN : test de la stratégie de négociation basée sur la politique de l'agent
Je suis ravi d'annoncer que nous avons franchi une étape importante de notre parcours : tester notre stratégie. À cette fin, nous utiliserons un framework Python de backtest simple pour effectuer nos tests. Pour commencer, vous pouvez installer le framework en exécutant la commande "pip install" suivie du nom du framework.
L'auteur du cadre a fourni un exemple simple qui montre comment l'utiliser efficacement. Cependant, avant de plonger là-dedans, nous devons mettre en œuvre notre propre stratégie. Commençons par initialiser et définir toutes les variables dont nous aurons besoin pour notre stratégie.
Un aspect intéressant est que nous pouvons charger notre politique enregistrée à l'aide de l'API TensorFlow. Puisque nous utilisons un QRNNNetwork, nous devons obtenir l'état initial de la politique. Par conséquent, nous avons implémenté la fonction d'initialisation. Maintenant, il est temps d'implémenter la fonction "next", qui sera appelée pour chaque nouvelle étape. Au départ, nous devons collecter des données pour les 10 premiers jours, et après, nous pouvons alimenter notre dictionnaire d'observation. À chaque étape, nous mettons à jour l'observation et la transmettons à la politique.
Une fois que nous avons créé le dictionnaire d'observation, nous devons créer un objet timestep puisque notre modèle de politique l'exige comme entrée. Pour faciliter ce processus, j'ai créé une fonction simple qui convertit nos données d'observation en objet timestep. Les éléments cruciaux ici sont les données d'observation et step_type. Après avoir obtenu notre objet timestep, nous pouvons récupérer une action de la politique. Comme vous pouvez le voir, la fonction "runPolicy" réinitialise l'état de la politique si le step_type est égal à 0 et renvoie l'action et le nouveau policy_state.
Ensuite, nous devons mettre à jour nos états de position et exécuter l'action. Enfin, à la fin de la fonction « suivant », on incrémente le compteur et on remet le tout aux états initiaux pour simuler le début d'un nouvel épisode. Super! Nous avons mis en œuvre notre stratégie avec succès. Maintenant, nous avons besoin de certaines données à des fins de test. Nous pouvons utiliser la bibliothèque panda_datareader pour récupérer les données quotidiennes de Yahoo Finance. Commençons par tester notre stratégie sur l'action Intel, en utilisant des données historiques d'un an.
Nous créons un objet backtest et commençons les tests. Les résultats des tests montrent un rendement de 106%, ce qui est impressionnant. Cependant, il est important de noter que le cadre de backtesting commence les calculs à partir de 100 %, ce qui signifie que notre rendement réel n'est que de 6 %. Néanmoins, ce n'est pas un mauvais résultat étant donné que notre politique n'a pas fait l'objet d'une formation approfondie. Pour fournir une évaluation plus complète, testons également notre stratégie sur les actions AMD. Comme vous pouvez le voir, le résultat pour AMD montre une baisse d'environ 40 %. Ainsi, nous pouvons comparer les performances de notre stratégie côte à côte sur les actions AMD et Intel.
Vous savez maintenant comment utiliser la politique de l'agent avec un framework de backtesting. De même, si vous utilisez Python pour votre environnement commercial réel, vous pouvez utiliser la politique de la même manière. Cependant, pour ceux qui utilisent d'autres langages, vous pouvez déployer la stratégie à l'aide du framework Flask et y accéder via une API REST.
J'espère que vous avez trouvé ces vidéos intéressantes et instructives. Si vous l'avez fait, pensez à vous abonner, et je vous verrai dans le prochain épisode.
Qu'est-ce qu'un système de trading quantitatif ? Structuration et descriptif.
Qu'est-ce qu'un système de trading quantitatif ? Structuration et descriptif.
Bonjour à tous! J'espère que vous allez tous bien. Cela fait un certain temps que je n'ai pas publié de vidéo, mais je tiens à vous assurer que je ne vous ai pas oublié. Aujourd'hui, je suis ravi de commencer un sujet nouveau et intéressant : l'architecture logicielle d'un système de trading automatisé.
Avant de nous plonger dans les détails de l'architecture logicielle, commençons par comprendre ce qu'est un système de trading et en quoi il consiste. Dans cette vidéo, nous allons explorer la structure et les éléments d'un système de trading automatisé. Maintenant, comme le dit le dicton, "Il n'y a rien de nouveau sous le soleil." Lorsque j'ai commencé mon voyage dans ce domaine, j'étais à la recherche d'une description bien structurée d'un système commercial. Je voulais quelque chose qui permettrait de comprendre facilement quels blocs mettre en œuvre et comment créer une solution logicielle robuste.
Je suis tombé sur un livre de Rishi K. Narang intitulé "Inside the Black Box", où il décrit un système quantitatif composé de cinq blocs communs : le modèle alpha, le modèle de risque, le modèle de coût de transaction, le modèle de construction de portefeuille et le modèle d'exécution. De plus, il existe un autre bloc essentiel : les données.
Examinons de plus près cette structure, en commençant par le bloc de données. Bien que le bloc de données ne fasse pas techniquement partie du système commercial, il joue un rôle vital en tant qu'oxygène sur lequel reposent tous les composants du système. Le bloc de données englobe divers types de données requises par le système commercial. Ces données peuvent provenir de différentes sources telles que les bourses, les régulateurs, les agences de presse et d'autres sources pertinentes telles que les données microéconomiques, les frais de courtage ou les informations sur les portefeuilles.
Maintenant que nous comprenons le bloc de données, explorons les éléments du système commercial et les relations entre eux. Dans le diagramme, vous pouvez voir des flèches représentant le flux d'informations. Le modèle alpha, le modèle de risque et le modèle de coût de transaction ne prennent pas de décisions finales ; au lieu de cela, ils fournissent des informations au modèle de construction de portefeuille, qui, à son tour, déclenche le modèle d'exécution. Il est important de noter qu'il existe des stratégies où seul un sous-ensemble de ces éléments est présent, et les relations entre les éléments peuvent varier. Cependant, cette structure nous donne une vision holistique des principaux éléments d'un système commercial.
Le premier élément de cette structure est le modèle alpha. Le modèle alpha représente l'idée ou la stratégie de trading conçue pour prédire les résultats futurs. Généralement, la sortie de ce modèle est une prévision de retour ou de direction. Il existe deux types de modèles de trading bien connus : les modèles techniques basés sur les données de prix et l'analyse technique, et les modèles fondamentaux qui utilisent les données financières et l'analyse fondamentale. Nous pouvons également avoir des modèles hybrides qui combinent des aspects des deux. Indépendamment de la complexité, l'objectif principal du modèle alpha est de fournir des conseils sous forme de prévisions.
Ensuite, nous avons le modèle de risque. Le modèle de risque est conçu pour aider à réduire ou à minimiser l'exposition aux facteurs qui pourraient entraîner des pertes. Les modèles de risque peuvent être classés en deux types. Le premier type se concentre sur le dimensionnement des positions pour réduire les risques, en utilisant des stratégies telles que le dimensionnement strict ou des fonctions complexes. La sortie de ce type de modèle de risque est la taille de la position. Le deuxième type de modèle de risque vise à atténuer des types de risques spécifiques, tels que le risque de direction du marché. Dans de tels cas, le modèle peut suggérer une position de couverture comme sortie.
Le troisième élément est le modèle de coût de transaction. Ce modèle fournit des informations sur le coût associé à l'exécution d'une transaction. Il y a trois coûts principaux : les commissions et les frais, le glissement et l'impact sur le marché. Les modèles de coût de transaction peuvent aller de modèles simples qui renvoient une valeur de coût fixe à des modèles plus complexes, comme les fonctions de coût quadratiques, qui visent à prédire le coût réel aussi précisément que possible. Le graphique ci-dessous montre comment différentes fonctions de coût peuvent fonctionner.
Une fois que nous avons tous les éléments qui fournissent des informations, nous passons au modèle de construction de portefeuille. Ce modèle prend des entrées du modèle alpha, du modèle de risque et du modèle de coût de transaction, et décide comment allouer les fonds entre différents actifs. Il vise à construire un portefeuille basé sur une fonction objective. Il existe deux principaux types de modèles de construction de portefeuille : les modèles basés sur des règles (par exemple, pondérations égales, risques égaux, méthodes d'arbre de décision) et les optimiseurs de portefeuille. Cette dernière consiste à optimiser une fonction objectif pour parvenir à une allocation d'actifs plus optimale dans le portefeuille.
Enfin, nous avons le modèle d'exécution, qui reçoit des informations du modèle de construction de portefeuille et se concentre sur l'exécution des ordres au meilleur prix possible. Il existe différents types de modèles d'exécution, allant des simples ordres de marché ou à cours limité aux plus complexes qui analysent la microstructure du marché et utilisent des algorithmes d'apprentissage automatique.
Ainsi s'achève la brève description des principaux éléments d'un système commercial quantitatif. J'espère que cet aperçu vous a permis de mieux comprendre la structure du système commercial et son fonctionnement en général.
Dans les prochaines vidéos, je vais essayer de créer une architecture système logicielle basée sur cette description. Si vous trouvez ce sujet intéressant, pensez à vous abonner à la chaîne pour les futures mises à jour. Merci d'avoir regardé, et je vous verrai dans la prochaine vidéo.