Python dans le Trading Algorithmique - page 24
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
Comment calculer la volatilité du portefeuille d'investissement en actions avec Python, NumPy et Pandas
Comment calculer la volatilité du portefeuille d'investissement en actions avec Python, NumPy et Pandas
Dans cette vidéo, le présentateur montre comment calculer la volatilité d'un portefeuille d'investissement à l'aide de Python et inclut les équations mathématiques sous-jacentes. L'accent est mis sur un portefeuille à deux titres, car il est facile à calculer sur une calculatrice de poche. Toutefois, le présentateur mentionne que pour les portefeuilles de plus de trois titres, la multiplication matricielle est utilisée pour calculer la volatilité. Le présentateur utilise la bibliothèque NumPy et d'autres bibliothèques de support pour effectuer les calculs.
La vidéo commence par la configuration de l'environnement Python et l'importation des modules nécessaires. Le présentateur définit ensuite les variables qui seront utilisées tout au long du processus.
Pour obtenir des données en temps réel pour le portefeuille, le présentateur mentionne l'utilisation d'une API et démontre spécifiquement l'utilisation de données historiques de fin de journée. Ils expliquent qu'une clé API est requise pour accéder aux données et fournissent des instructions sur la façon de s'enregistrer et d'obtenir la clé. La date de début des données est fixée à il y a environ un an. Le présentateur configure le portefeuille, attribue des pondérations égales à chaque titre et crée une liste vide pour stocker les données téléchargées.
À l'aide d'une boucle for, le présentateur effectue des appels d'API pour chaque symbole du portefeuille et récupère les données. Ils montrent comment construire l'appel d'API en obtenant l'URL du point de terminaison sur le site Web du fournisseur de données et en apportant les modifications nécessaires. Les données sont récupérées sous forme de chaîne JSON, qui est convertie en DataFrame pandas pour un traitement ultérieur. Les cours de clôture sont extraits du DataFrame et ajoutés à la liste de données.
Après avoir terminé la boucle for, le présentateur convertit la liste de données en DataFrame, la transpose, renomme les colonnes avec les noms de symboles et modifie l'index en dates. Ils affichent ensuite le DataFrame résultant contenant les cours de clôture de chaque titre.
Pour calculer la volatilité, le présentateur explique qu'il faut calculer des taux de rendement instantanés. Ils créent un nouveau DataFrame en utilisant la fonction logarithme de NumPy sur les cours de clôture, puis calculent les différences entre les valeurs consécutives. Le DataFrame résultant représente les taux de rendement instantanés pour chaque titre. Le présentateur supprime la première ligne du DataFrame pour gérer toutes les valeurs NaN et démontre le calcul de la variance pour chaque titre.
Pour calculer la volatilité de chaque titre, le présentateur utilise la racine carrée de la variance. Ils affichent les volatilités résultantes en pourcentages.
Pour la volatilité du portefeuille, le présentateur explique qu'elle peut être calculée comme la moyenne pondérée des volatilités de chaque titre. Étant donné que les titres de l'exemple sont équipondérés, le présentateur n'a besoin que de la moyenne des volatilités. Ils le formatent en pourcentage.
Ensuite, le présentateur introduit le concept de matrice de covariance et montre comment la calculer à l'aide du DataFrame de retour. Ils ajustent la covariance quotidienne à une covariance annuelle et affichent la matrice de covariance résultante.
Enfin, le présentateur calcule la volatilité du portefeuille en utilisant la multiplication matricielle. Ils multiplient les poids par la matrice de covariance et prennent la racine carrée du résultat. La volatilité du portefeuille est affichée en pourcentage, représentant l'écart type.
En conclusion, la vidéo fournit une démonstration étape par étape de la façon de calculer la volatilité d'un portefeuille à l'aide de Python. Le présentateur explique les calculs nécessaires, présente les bibliothèques pertinentes telles que NumPy et souligne les avantages de la diversification pour réduire la volatilité du portefeuille.
Premiers pas avec Steamlit pour Python - Créez une application Web fonctionnelle en quelques minutes
Premiers pas avec Steamlit pour Python - Créez une application Web fonctionnelle en quelques minutes
Dans cette vidéo, je vais montrer comment utiliser Streamlit for Python pour créer une application Web. Streamlit est une interface utilisateur Web gratuite qui vous permet de créer et de partager des applications de haute qualité sans aucune expérience de développement frontal. Nous allons créer une application simple qui nous permet de télécharger des données sur le cours des actions à l'aide d'une API et de les représenter graphiquement. Commençons!
Tout d'abord, j'utiliserai PyCharm comme IDE, mais vous pouvez utiliser n'importe quel IDE de votre choix. Si vous n'êtes pas familier avec PyCharm, j'ai fourni un lien dans la description de la vidéo pour une vidéo « Premiers pas avec PyCharm ». N'hésitez pas à le consulter si vous souhaitez en savoir plus.
J'ai déjà configuré un nouveau projet dans PyCharm appelé "Streamlit Demo" et ajouté un fichier Python. Puisque nous commençons avec un nouvel environnement virtuel, nous devons installer certaines dépendances. Nous aurons besoin de Pandas, de la bibliothèque Requests et de Streamlit. Selon votre configuration PyCharm, vous avez peut-être déjà installé Pandas et Requests, mais vous devrez certainement installer Streamlit. De plus, nous utiliserons l'API "End of Day Historical Data" pour notre application, qui permet des appels d'API gratuits avec une limite d'environ 20 par jour. Si vous avez besoin de plus que cela, ils proposent des options d'abonnement sur leur site Web.
Une fois Streamlit installé, examinons leur exemple d'application. Je vais ouvrir le terminal et exécuter Streamlit en appelant Python depuis la ligne de commande, puis en exécutant la commande Streamlit. Leur exemple d'application se trouve dans un fichier appelé "hello". Après quelques secondes, l'application démarrera et vous verrez une page Web avec un en-tête, du texte et des hyperliens. Sur le côté gauche, il y a diverses démonstrations que vous pouvez explorer. La bonne chose à propos de leurs démos est qu'elles fournissent le code utilisé pour générer la sortie. Par exemple, il y a une démo avec un graphique, et en dessous, vous pouvez voir le code utilisé pour générer ce graphique. Streamlit s'occupe du formatage et du placement du contenu sur la page Web, vous n'avez donc qu'à vous concentrer sur l'écriture du code pour produire la sortie souhaitée.
Une fois que vous êtes satisfait de votre application, vous pouvez demander l'autorisation à Streamlit de la publier en direct. Ils offrent toujours la publication gratuite, mais vous devez les contacter pour la configurer. Ensuite, vous pouvez transférer vos fichiers sur GitHub et partager votre application en direct en quelques secondes.
Passons maintenant à la création de notre propre application. Je vais démontrer quelques fonctionnalités de Streamlit avant de commencer à écrire notre code d'application. Streamlit fournit divers éléments que vous pouvez utiliser, tels que des boutons, des sélecteurs de couleurs, des barres latérales, des zones de texte et des sélecteurs de date. L'élément le plus couramment utilisé est la fonction "écrire", qui permet d'afficher du texte sur la page Web. Vous pouvez également utiliser la syntaxe Markdown dans la fonction "write" pour formater le texte. De plus, si vous souhaitez afficher du texte de forme libre, vous pouvez simplement utiliser une docstring, et Streamlit le rendra sous forme de démarque.
Testons certaines de ces fonctionnalités en écrivant une application de base. Je vais définir quelques dépendances puis vous montrer comment utiliser les éléments Streamlit. Nous commencerons par la fonction "st" et explorerons ses différentes capacités. Par exemple, nous pouvons utiliser "st.button" pour afficher un bouton, "st.color_picker" pour un sélecteur de couleur et "st.sidebar" pour créer une barre latérale. La fonction "write" est également très utile pour afficher du texte, et vous pouvez y utiliser la syntaxe Markdown. Je vais démontrer ces fonctionnalités communes, mais gardez à l'esprit que Streamlit offre de nombreuses autres options.
Pour exécuter l'application, je vais arrêter le serveur Streamlit actuel et le redémarrer en exécutant la commande Python avec le nom.
Voici un exemple d'application Streamlit simple qui vous permet de télécharger et de représenter graphiquement les données sur le cours des actions :
Dans cet exemple, nous importons d'abord les bibliothèques nécessaires : Streamlit, Pandas et Requests. Nous définissons ensuite le titre et la mise en page à l'aide des fonctions st.title() et st.sidebar.header().
Ensuite, nous créons des champs de saisie dans la barre latérale à l'aide de la fonction st.sidebar.text_input(). Les utilisateurs peuvent entrer un symbole boursier, une date de début et une date de fin dans ces champs.
Nous créons ensuite un bouton en utilisant la fonction st.sidebar.button(). Lorsque le bouton est cliqué, il déclenche le processus de récupération des données. Nous construisons l'URL de demande d'API à l'aide du symbole saisi, de la date de début et de la date de fin. Nous faisons une requête GET à l'API en utilisant la fonction requests.get().
Si la requête API aboutit (code d'état 200), nous récupérons les données de la réponse et créons un Pandas DataFrame. Nous affichons les données téléchargées à l'aide de la fonction st.write(), puis créons un graphique linéaire des prix des actions à l'aide de la fonction st.line_chart().
Si la requête API échoue, nous affichons un message d'erreur à l'aide de la fonction st.write().
Enfin, nous ajoutons quelques informations supplémentaires à la barre latérale à l'aide de la fonction st.sidebar.info().
Pour exécuter cette application, vous pouvez l'enregistrer dans un fichier Python (par exemple, stock_app.py) et l'exécuter à l'aide de la commande streamlit run stock_app.py dans votre terminal.
Ceci n'est qu'un exemple de base, et vous pouvez le personnaliser davantage en fonction de vos besoins. Streamlit offre de nombreuses autres fonctionnalités pour créer des applications Web interactives, notamment des listes déroulantes, des cases à cocher, des curseurs, etc. Vous pouvez explorer la documentation Streamlit ( https://docs.streamlit.io/ ) pour plus d'informations et d'exemples.
Utilisez l'API de données historiques de fin de journée (EOD) pour trouver l'heure du haut/bas quotidien
Utilisez l'API de données historiques de fin de journée (EOD) pour trouver l'heure du haut/bas quotidien
Dans cette vidéo, nous allons explorer l'API de données historiques de fin de journée, qui nous permet d'extraire les cours quotidiens les plus élevés et les plus bas d'une action. Cette API fait partie d'un modèle freemium pour les données financières, offrant 20 appels d'API gratuits par jour. L'avantage de cette API est qu'elle donne accès aux données de plus de 70 bourses mondiales. Vous pouvez trouver le lien vers leur site Web et les prix spéciaux dans la description de la vidéo.
Pour commencer, nous devons configurer notre environnement. Nous utiliserons le module datetime pour manipuler les dates, la bibliothèque d'assistance pour accéder aux données historiques, les pandas pour la manipulation et le filtrage des données et les demandes pour effectuer des appels d'API. Ensuite, nous devons obtenir notre clé API, qui peut être stockée dans un fichier ou directement dans le cahier pour plus de simplicité.
Nous définirons également la date de début de nos données, qui remonte généralement à environ 10 jours. L'API a différentes limitations en fonction du type de données, avec des données minute par minute limitées à 120 jours et des données d'intervalle de cinq minutes limitées à 600 jours. L'API indexe les données à l'aide de l'horodatage Unix, qui représente le nombre de secondes écoulées depuis le 1er janvier 1970. Nous convertissons la date de début souhaitée en un horodatage Unix pour la requête API.
Une fois la configuration nécessaire terminée, nous pouvons créer une instance de l'objet "Données historiques de fin de journée" à l'aide de notre clé API. Cet objet nous permet de récupérer les données dont nous avons besoin. La bibliothèque d'assistance fournit divers points de terminaison qui peuvent être explorés pour différents types de données. Dans cet exemple, nous nous concentrerons sur la récupération des prix intrajournaliers pour Tesla en utilisant des intervalles d'une minute, à partir de la date de début spécifiée.
Pour visualiser les données, nous pouvons envelopper l'appel d'API dans un constructeur pour un Pandas DataFrame. Cela facilite l'utilisation et la visualisation des données. Nous affichons les premières lignes du DataFrame pour vérifier les données récupérées, y compris l'horodatage, la date et l'heure Unix.
Si vous préférez ne pas utiliser la bibliothèque d'assistance, la vidéo propose une approche alternative utilisant la bibliothèque de requêtes pour accéder directement au point de terminaison de l'API et récupérer les données JSON.
Ensuite, nous effectuons un nettoyage des données. Nous remplaçons l'index basé sur des nombres entiers par la date et l'heure des données. Nous ajoutons des colonnes séparées pour l'heure et la date, et supprimons les colonnes inutiles telles que le décalage GMT et l'heure de la date d'origine. Le DataFrame résultant montre la structure révisée avec les colonnes ajoutées.
Pour nous concentrer sur les heures de trading régulières, nous créons une copie des données d'origine. Étant donné que l'index est un objet datetime, nous pouvons utiliser la méthode between_time pour filtrer les heures souhaitées. Comme le mentionne la vidéo, le fuseau horaire pour ces données est GMT-5, nous ajustons donc les heures en conséquence. Nous convertissons également les heures en heure de l'Est (ET) pour une interprétation plus facile.
Pour filtrer uniquement l'heure de la colonne datetime, nous effectuons quelques étapes supplémentaires. Comme nous avons déjà effectué un calcul, nous devons formater à nouveau les données avant d'appliquer la méthode datetime pour extraire l'heure. Le DataFrame résultant affiche les heures ajustées à New York.
Enfin, nous abordons la question initiale de savoir quand les hauts et les bas se produisent pendant la journée de négociation. Nous récupérons d'abord le haut et le bas généraux pour chaque jour en utilisant la fonction groupby et les méthodes min et max. Pour déterminer le moment précis de ces hauts et bas, nous localisons l'index des valeurs minimales et maximales dans le DataFrame, respectivement. Cela donne un aperçu du calendrier de ces niveaux de prix, ce qui nous permet d'observer tous les modèles ou tendances.
Dans l'ensemble, cette vidéo fournit un guide étape par étape sur l'utilisation de l'API de données historiques de fin de journée, la récupération des données sur les cours des actions et l'analyse du moment des prix de négociation élevés et bas.
Comment tester les algorithmes de trading et les métriques de portefeuille avec Python et QuantStats
Comment tester les algorithmes de trading et les métriques de portefeuille avec Python et QuantStats
Aujourd'hui, je vais vous présenter un aperçu complet de Quant stats, une vaste bibliothèque de mesures financières conçue comme un outil de profilage de portefeuille. Avec Quant stats, vous pouvez générer des rapports détaillés sans effort en utilisant une simple ligne. Cet outil vous permet de mesurer efficacement les performances du portefeuille et de backtester les algorithmes de trading.
Quant stats s'appuie sur des bibliothèques de science des données bien connues que vous connaissez peut-être déjà et que vous utilisez. Pour cette démonstration, je travaille dans PyCharm et j'ai commencé un nouveau projet. Si vous suivez, assurez-vous que les dépendances nécessaires sont installées. J'utilise une version légèrement plus ancienne de Pandas car les statistiques Quant n'ont pas été mises à jour depuis environ six mois, et il peut y avoir des problèmes de compatibilité avec les dernières versions de Pandas.
Pour vous assurer que vous disposez des dépendances requises, vous pouvez les ajouter à un fichier requirements.txt et les installer à l'aide de Pip. De plus, Quant stats se compose de trois modules : statistiques, graphiques et rapports. En raison de la fonctionnalité étendue, je ne pourrai pas tout couvrir dans cette seule vidéo. Cependant, je vais vous donner un aperçu et vous guider sur la façon de commencer. Vous pouvez ensuite explorer davantage en fonction de vos besoins et intérêts spécifiques.
Avant de plonger dans les détails, prenons un moment pour écouter notre sponsor. Si vous souhaitez apprendre à créer des algorithmes de trading avec Python, laissez Looming Wealth vous aider dans son cours de trading algorithmique. Dans ce cours, vous apprendrez à créer des robots qui négocient automatiquement en votre nom, à mettre en œuvre et à utiliser des mesures techniques et financières et à utiliser l'apprentissage automatique pour développer des algorithmes de trading uniques. Vous pouvez apprendre à votre rythme ou rejoindre des cours en direct pour une expérience d'apprentissage collaborative. Suivez le lien ci-dessous pour en savoir plus sur Looming Wealth et bénéficiez d'une réduction de 15% sur l'un de leurs cours de trading.
Revenons maintenant aux statistiques Quant. Dans un nouveau fichier vierge, commencez par importer la bibliothèque Quant stats. Ensuite, définissez un symbole boursier à analyser. Pour cet exemple, j'utiliserai le S&P 500 ETF (SPY). Nous utiliserons les statistiques Quant pour examiner ses performances au cours des trois dernières années.
Pour télécharger les données de retour, nous utiliserons les utilitaires Quant stats, qui s'appuient sur les données de Yahoo Finance. Vous pouvez utiliser n'importe quelle source de données que vous préférez ; il n'y a pas de magie ici. Imprimons les retours pour voir ce que nous obtenons. La sortie sera une série Pandas avec des rendements quotidiens couvrant la période spécifiée.
Une fois que nous avons les données de retour, nous pouvons calculer diverses statistiques à l'aide des statistiques Quant. Il existe de nombreuses fonctions disponibles, bien plus que ce que nous pouvons couvrir dans cette vidéo. Vous pouvez obtenir une liste des statistiques disponibles en imprimant l'attribut available_stats. Affichons une liste compréhensive des statistiques disponibles, à l'exclusion des fonctions privées.
Je vais commenter une partie de la compréhension de la liste pour la garder concise. Nous allons procéder à l'impression de quelques statistiques communes pour le S&P 500 au cours des trois dernières années. Calculons le ratio de Sharpe en utilisant qs.stats.sharpe_ratio(). De plus, nous trouverons le meilleur jour et mois en appelant respectivement qs.stats.best_day() et qs.stats.best_month(). Vous pouvez modifier ces appels pour agréger les données différemment si nécessaire.
Alternativement, Quant stats fournit un wrapper pour Pandas, vous permettant d'effectuer des appels de méthode directement sur l'objet de portefeuille. En étendant Pandas, vous pouvez utiliser des one-liners pour accéder à diverses statistiques. Par exemple, vous pouvez appeler Quant stats.extend_pandas() puis utiliser l'objet portfolio pour récupérer des statistiques telles que le rendement brut annuel composé et le drawdown maximum.
En plus des statistiques, Quant stats offre également la possibilité de construire des portefeuilles.
Ensuite, je vais calculer les signaux en fonction de la stratégie de croisement de moyenne mobile. Si la moyenne mobile rapide est supérieure à la moyenne mobile lente, c'est un signal d'achat. Sinon, c'est un signal de vente. Je vais ajouter ces signaux à la trame de données.
Après cela, je vais calculer les positions en fonction des signaux. S'il s'agit d'un signal d'achat, je définirai la position sur 1 (indiquant une position longue), et s'il s'agit d'un signal de vente, je définirai la position sur -1 (indiquant une position courte). Tous les autres cas seront mis à 0 (indiquant aucune position).
Maintenant que nous avons les positions, je vais calculer les rendements de la stratégie. Pour ce faire, je vais multiplier les positions par les rendements quotidiens de l'actif. Cela nous donnera les rendements quotidiens de la stratégie.
Ensuite, je calculerai les rendements cumulés de la stratégie en prenant le produit cumulé des rendements quotidiens. Cela nous donnera la croissance de la stratégie au fil du temps.
Enfin, je vais générer le rapport à l'aide de la fonction quantstats.reports.html. Cette fonction prend les données de retours cumulés et génère un rapport HTML avec diverses mesures de performances et visualisations. Je vais enregistrer le rapport sous forme de fichier HTML.
Pour afficher le rapport automatiquement, j'ouvre le fichier à l'aide du navigateur Web. Et c'est tout pour le code.
Désormais, lorsque vous exécutez ce code avec les paramètres choisis, il génère la stratégie de croisement de moyenne mobile, calcule les mesures de performance et génère un rapport HTML avec les résultats. Vous pouvez personnaliser les paramètres de la stratégie, tels que les périodes de moyenne mobile ou la fenêtre temporelle, en fonction de vos besoins.