Python dans le Trading Algorithmique - page 23
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
Équilibrage des données de séquence RNN - Deep Learning avec Python, TensorFlow et Keras p.10
Équilibrage des données de séquence RNN - Deep Learning avec Python, TensorFlow et Keras p.10
Bonjour à tous et bienvenue dans un autre didacticiel vidéo sur l'apprentissage en profondeur avec Python, TensorFlow et Keras. Dans cette vidéo, nous allons continuer à nous appuyer sur notre futur prédicteur de mouvement des prix des crypto-monnaies en utilisant un réseau neuronal récurrent (RNN)."
La vidéo du didacticiel est axée sur la création d'un prédicteur du mouvement des prix des crypto-monnaies à l'aide de techniques d'apprentissage en profondeur.
Le présentateur mentionne qu'ils ont déjà effectué des étapes de prétraitement, y compris la construction de données séquentielles et la séparation des données de validation. Ils ont également normalisé les données.
La prochaine étape du processus consiste à équilibrer les données. Il est important d'avoir un nombre égal d'instances d'achat et de vente dans l'ensemble de données. S'il y a un déséquilibre, cela peut affecter les performances du modèle. Le présentateur suggère que même s'il y a un léger déséquilibre, il est préférable d'équilibrer les données pour éviter que le modèle ne favorise une classe par rapport à l'autre.
Pour équilibrer les données, le présentateur crée deux listes : achète et vend. Ils parcourent les données séquentielles et vérifient si la cible est un 0 (vente) ou 1 (achat). S'il s'agit d'une vente, ils ajoutent la séquence à la liste des ventes. S'il s'agit d'un achat, ils l'ajoutent à la liste des achats. Ensuite, ils mélangent les deux listes.
Ensuite, ils trouvent la longueur minimale entre les deux listes (achats et ventes). Ils mettent à jour les listes d'achats et de ventes pour ne contenir que les éléments jusqu'à la longueur de la liste la plus courte. Cela garantit que les deux listes ont un nombre égal d'instances.
Ensuite, le présentateur combine les listes d'achats et de ventes dans la liste sequential_data. Ils mélangent à nouveau la liste sequential_data pour randomiser davantage l'ordre des données.
L'étape suivante consiste à diviser les données séquentielles en entités (X) et étiquettes (Y). Ils créent des listes vides x et y pour stocker respectivement les caractéristiques et les étiquettes. Ils itèrent sur les sequential_data et ajoutent la séquence à la liste x et la cible à la liste y.
Enfin, ils renvoient les tableaux de x et y en tant que données prétraitées.
Le présentateur procède ensuite à l'impression de certaines statistiques sur les données, telles que la taille des ensembles de données de formation et de validation, et l'équilibre entre les instances d'achat et de vente.
Dans la vidéo suivante, ils prévoient de créer et de former le modèle à l'aide des données prétraitées.Modèle RNN de prédiction de crypto-monnaie - Deep Learning avec Python, TensorFlow et Keras p.11
Modèle RNN de prédiction de crypto-monnaie - Deep Learning avec Python, TensorFlow et Keras p.11
Bonjour à tous et bienvenue dans un autre tutoriel d'apprentissage en profondeur avec Python, TensorFlow et Keras. Dans ce didacticiel, nous continuerons là où nous nous sommes arrêtés dans le didacticiel précédent. Notre objectif est de prédire les mouvements futurs des prix d'une crypto-monnaie spécifique en fonction de ses prix historiques, de son volume et d'autres crypto-monnaies majeures. Nous y parviendrons en utilisant un réseau neuronal récurrent (RNN).
Pour commencer, nous devons importer les bibliothèques nécessaires. Nous allons importer la bibliothèque de temps pour une utilisation ultérieure. Ensuite, nous définissons quelques constantes. La première constante est le nombre d'époques pour lesquelles nous voulons former le modèle. Nous avons initialement défini la taille du lot sur 64, mais nous pouvons l'ajuster ultérieurement si nécessaire. Enfin, nous définissons un nom pour le modèle à l'aide d'une chaîne F. Il est important d'avoir un nom unique pour le modèle et les journaux TensorBoard pour faciliter la comparaison et l'identification.
Maintenant, nous importons les modules TensorFlow requis. Nous importons TensorFlow en tant que tf et les sous-modules requis : tf.keras.models, tf.keras.layers, tf.keras.optimizers, tf.keras.callbacks et tf.keras.backend. Nous importons également numpy et matplotlib pour le traitement et la visualisation des données.
Ensuite, nous commençons à construire notre modèle. Nous créons un modèle séquentiel en utilisant model = tf.keras.models.Sequential(). À l'intérieur du modèle, nous ajoutons des couches à l'aide de la fonction model.add(). Notre première couche est une couche LSTM avec 128 nœuds. Nous définissons return_sequences=True puisque nous voulons transmettre la sortie à la couche suivante. Nous spécifions la forme d'entrée comme train_X.shape[1:], où train_X est les données d'entrée. Nous ajoutons également une couche de suppression avec un taux de 0,2 et une couche de normalisation par lots.
Nous répétons ce processus deux fois de plus, en ajoutant deux autres couches LSTM avec 128 nœuds chacune. Nous supprimons return_sequences=True pour la dernière couche LSTM puisqu'elle sera suivie d'une couche dense. Nous ajoutons également des couches d'abandon et de normalisation par lots à chaque couche LSTM.
Après les couches LSTM, nous ajoutons une couche dense avec 32 nœuds et une fonction d'activation linéaire rectifiée. Nous ajoutons une couche de décrochage avec un taux de 0,2 et enfin, la couche de sortie avec deux nœuds et une fonction d'activation softmax.
Maintenant, nous spécifions l'optimiseur pour notre modèle. Nous utilisons l'optimiseur Adam avec un taux d'apprentissage de 0,001 et un taux de décroissance de 1e-6. Nous compilons le modèle à l'aide de model.compile() et spécifions la fonction de perte en tant qu'entropie croisée catégorique clairsemée et les métriques en tant que précision.
Ensuite, nous définissons les rappels pour notre modèle. Nous créons un rappel TensorBoard avec le répertoire de journaux défini sur "logs". Nous créons également un rappel ModelCheckpoint pour enregistrer le meilleur modèle lors de la formation. Nous spécifions le chemin du fichier pour enregistrer les points de contrôle en utilisant le formatage de chaîne.
Enfin, nous formons le modèle à l'aide de model.fit(). Nous transmettons les données d'apprentissage (train_X et train_Y), la taille du lot, le nombre d'époques et les données de validation (validation_X et validation_Y). Nous passons également les rappels que nous avons définis précédemment.
Après la formation, nous pouvons enregistrer le modèle en utilisant model.save() pour une utilisation future.
C'est ça! Nous avons construit et formé avec succès un modèle de réseau neuronal récurrent pour prédire les futurs mouvements de prix d'une crypto-monnaie. Nous avons également visualisé la progression de la formation à l'aide de TensorBoard.
Stratégie de trading algorithmique en Python
Stratégie de trading algorithmique en Python
Dans le didacticiel d'aujourd'hui, nous mettrons en œuvre une stratégie algorithmique de négociation d'actions à l'aide de Python. Plongeons-y directement.
Avant de commencer, je tiens à souligner que cette vidéo n'est pas destinée à fournir des conseils d'investissement ou financiers. Je ne suis pas un professionnel des actions, un expert en investissement ou un professionnel de la finance. Le but de cette vidéo est de montrer comment mettre en œuvre une stratégie de trading algorithmique à l'aide de Python. Que vous choisissiez de l'utiliser pour vos investissements relève entièrement de votre décision et de votre responsabilité. Je me concentrerai uniquement sur l'aspect programmation.
Pour commencer, nous devons installer deux bibliothèques : "pandas-datareader" pour récupérer les données boursières et "matplotlib" pour la visualisation des données. Ouvrez l'invite de commande (CMD) et installez ces bibliothèques. Une fois installé, nous pouvons procéder au codage.
Tout d'abord, nous importons les modules nécessaires : "datetime" pour gérer la date et l'heure, "matplotlib.pyplot" pour tracer des graphiques et "pandas_datareader" en tant que "web" pour récupérer les données boursières.
Ensuite, nous définissons les moyennes mobiles (MA) que nous utiliserons. Les moyennes mobiles représentent le prix moyen des actions sur une période de temps spécifiée, telle que 30 jours ou 100 jours. Nous créons deux variables, "ma1" et "ma2", qui seront respectivement définies sur 30 et 100. Ces valeurs déterminent la longueur des moyennes mobiles que nous allons analyser.
Maintenant, fixons le cadre temporel de notre analyse. Nous définissons les dates de début et de fin en utilisant la date actuelle et un décalage horaire de 3 ans. Ce laps de temps sera utilisé pour récupérer les données boursières.
À l'aide de la bibliothèque "datareader", nous récupérons les données boursières d'une entreprise spécifique (dans ce cas, Facebook) à partir de l'API Yahoo Finance. Nous transmettons les dates de début et de fin pour récupérer les données pertinentes.
Pour calculer les moyennes mobiles, nous ajoutons deux nouvelles colonnes aux données DataFrame. Nous utilisons la fonction "rolling" pour calculer la moyenne mobile pour les périodes "ma1" et "ma2". La colonne "clôture ajustée" représente le cours de clôture ajusté pour les fractionnements d'actions. Nous stockons les moyennes mobiles dans les colonnes respectives.
Avant d'aller plus loin, visualisons les données et les moyennes mobiles. Nous traçons les valeurs de clôture ajustées en tant que cours de l'action et les moyennes mobiles sont tracées sur le même graphique. Nous définissons le style de graphique pour utiliser un arrière-plan sombre et donnons des étiquettes et des couleurs appropriées pour différencier les lignes. Enfin, nous ajoutons une légende pour identifier les lignes tracées et afficher le graphique.
Passons maintenant à la mise en œuvre de la stratégie de trading algorithmique. Nous créons deux listes vides, "buy_signals" et "sell_signals", qui stockeront respectivement les signaux d'achat et de vente. De plus, nous introduisons une variable "déclencheur" qui nous aidera à suivre les changements dans la stratégie.
À l'aide d'une boucle for, nous parcourons les données DataFrame. A l'intérieur de la boucle, on vérifie deux conditions : si la première moyenne mobile ("ma1") est supérieure à la deuxième moyenne mobile ("ma2"), et si le trigger n'est pas égal à 1. Si les deux conditions sont remplies, on ajoute un signal d'achat à la liste "buy_signals" et ajoutez "NaN" (pas un nombre) à la liste "sell_signals". Nous mettons également à jour le déclencheur à 1.
Dans le cas contraire, où "ma1" est inférieur à "ma2" et le déclencheur n'est pas égal à -1, nous ajoutons un signal de vente à la liste "sell_signals" et ajoutons le cours réel de l'action à la liste "buy_signals". Nous mettons à jour le déclencheur à -1.
Si aucune des conditions n'est remplie, nous ajoutons des valeurs "NaN" aux deux listes pour maintenir des longueurs cohérentes.
Enfin, nous ajoutons deux colonnes supplémentaires aux données DataFrame pour stocker les signaux d'achat et de vente.
Nous allons également disperser les signaux de vente, nous allons donc ajouter un autre nuage de points en utilisant plt.scatter. Cette fois, nous allons disperser les signaux de vente sur data.index en tant que valeurs x, et les prix des signaux de vente correspondants en tant que valeurs y. Nous appellerons ce nuage de points "signal de vente" pour le différencier des signaux d'achat.
Enfin, nous ajouterons une légende au tracé en utilisant plt.legend pour afficher les étiquettes des différents éléments. Ensuite, nous appellerons plt.show() pour afficher le tracé.
Le code:
N'oubliez pas qu'il ne s'agit que d'une simple stratégie de trading algorithmique implémentée en Python, et qu'elle n'est pas destinée à être considérée comme un conseil financier ou d'investissement. Il est important de faire des recherches approfondies et de consulter des professionnels avant de prendre toute décision d'investissement.
Introduction au trading algorithmique avec Python - Comment créer et tester un algorithme de trading
Introduction au trading algorithmique avec Python - Comment créer et tester un algorithme de trading
Dans cette vidéo, nous allons nous plonger dans le développement d'une stratégie de trading algorithmique. Il est crucial de noter que cette vidéo est destinée à des fins éducatives uniquement et ne doit pas être considérée comme un conseil en investissement. La stratégie que nous allons explorer est communément appelée stratégie de momentum, bien que le terme lui-même puisse être ambigu et sujet à interprétation.
Essentiellement, une stratégie de momentum consiste à identifier les titres qui affichent un mouvement directionnel clair. Dans notre cas, nous commencerons par effectuer un processus de sélection pour identifier les titres qui se négocient au-dessus de leur moyenne mobile sur 50 jours ou de toute autre mesure prédéterminée que nous avons recherchée.
Cette stratégie est souvent qualifiée de stratégie de suivi de tendance, car elle vise à capitaliser sur des titres qui évoluent dans une direction spécifique, à la hausse ou à la baisse. Il est important de noter que cette approche nécessite une recherche approfondie pour identifier les signaux de trading potentiellement rentables qui peuvent être appliqués à divers titres.
Pour les besoins de cette vidéo, nous nous concentrerons sur l'analyse d'un seul titre afin de déterminer son potentiel. Pour commencer, nous allons importer les bibliothèques nécessaires et configurer notre environnement. Le cahier contenant le code sera mis à disposition sur un lien GitHub, qui se trouve dans la description de la vidéo.
Ensuite, nous téléchargerons les données requises pour l'analyse. Dans ce cas, nous utiliserons l'API Yahoo Finance pour récupérer les données du Gold ETF (Exchange Traded Fund) avec le symbole "GLD". Nous utiliserons le lecteur de données Pandas pour récupérer les données, en spécifiant le symbole et en laissant les dates de début et de fin par défaut, ce qui devrait nous fournir environ cinq ans de données. Une fois téléchargées, nous examinerons les premières lignes des données pour nous assurer de leur exactitude.
Pour faciliter notre analyse, nous allons ajouter des colonnes supplémentaires au bloc de données. Tout d'abord, nous inclurons une colonne de compteur de jours pour garder une trace du jour dans la série chronologique. Cela sera accompli en utilisant la bibliothèque NumPy pour créer un tableau de plage correspondant au nombre d'observations dans la trame de données d'or. La colonne du compteur de jours sera ensuite ajoutée au bloc de données, et nous ajusterons l'ordre des colonnes pour nous assurer que le jour suit la colonne de date.
De plus, nous supprimerons les colonnes inutiles telles que la clôture et le volume ajustés pour notre analyse spécifique. Il convient de mentionner que pour certains titres, la clôture ajustée peut être utile, en particulier dans les cas où il y a eu des fractionnements d'actions. Cependant, pour nos besoins, nous exclurons ces colonnes.
Après avoir terminé les étapes préliminaires, nous pouvons examiner la structure des données en exécutant la commande info sur la trame de données. Cela fournira des informations sur le nombre d'observations et de types de données présents dans le bloc de données, confirmant que toutes les colonnes sont numériques.
Ensuite, nous présenterons la stratégie de momentum en ajoutant des colonnes de moyenne mobile au bloc de données. Nous utiliserons deux moyennes mobiles, une rapide (9 jours) et une lente (21 jours), pour déclencher les transactions. Plus précisément, nous entrerons dans une transaction lorsque la moyenne mobile rapide passera au-dessus de la moyenne mobile lente, et nous sortirons ou prendrons une position courte lorsque la moyenne mobile rapide passera en dessous de la moyenne mobile lente. Il est essentiel de noter que cette stratégie suppose que nous sommes toujours dans un commerce, long ou court.
Pour calculer les moyennes mobiles basées sur le cours de clôture, nous utiliserons la méthode de roulement fournie par Pandas. Cette méthode nous permet de spécifier le nombre de jours pour la moyenne mobile. De plus, nous pouvons appliquer différents agrégateurs si vous le souhaitez, tels que l'écart type ou la médiane. Dans ce cas, nous nous concentrerons uniquement sur la moyenne mobile. Nous allons dupliquer ce processus pour les moyennes mobiles rapides et lentes, ce qui entraînera deux colonnes supplémentaires dans le bloc de données.
Étant donné que les moyennes mobiles sont décalées de 9 et 21 jours, respectivement, nous devons les ajuster en décalant les données d'un jour en utilisant la méthode de décalage dans Pandas.
Après avoir calculé les moyennes mobiles, nous les ajusterons en décalant les données d'un jour en utilisant la méthode de décalage dans Pandas. Cela garantit que les moyennes mobiles du jour en cours sont alignées sur l'action des prix du jour suivant.
Maintenant que nous avons ajusté les colonnes de moyenne mobile, nous pouvons générer des signaux de trading basés sur le croisement des moyennes mobiles rapides et lentes. Pour ce faire, nous allons créer une nouvelle colonne nommée "Signal" et lui attribuer la valeur 1 lorsque la moyenne mobile rapide est supérieure à la moyenne mobile lente, indiquant un signal haussier, et -1 lorsque la moyenne mobile rapide est inférieure à la moyenne mobile lente. moyenne mobile, indiquant un signal baissier.
Pour déterminer les points d'entrée et de sortie de nos transactions, nous ajouterons une autre colonne appelée "Position". Dans un premier temps, nous lui attribuerons une valeur de 0, indiquant que nous ne sommes pas dans un échange. Lorsqu'un signal haussier se produit (la moyenne mobile rapide passe au-dessus de la moyenne mobile lente) et que nous ne sommes pas actuellement dans une transaction (Position = 0), nous attribuerons une valeur de 1 à la colonne Position, indiquant une position longue. Inversement, lorsqu'un signal baissier se produit (la moyenne mobile rapide passe en dessous de la moyenne mobile lente) et que nous ne sommes pas actuellement dans une transaction, nous attribuerons une valeur de -1 à la colonne Position, indiquant une position courte. Cela garantit que nous entrons dans une transaction uniquement lorsqu'il y a un nouveau signal et que nous ne sommes pas déjà dans une transaction.
Pour suivre les rendements quotidiens de notre stratégie de trading, nous allons créer une autre colonne appelée "Strategy Returns". Nous calculerons les rendements quotidiens en multipliant la colonne Position par la variation quotidienne en pourcentage du cours de clôture. Cela nous donnera le rendement que nous aurions obtenu si nous avions suivi les signaux de trading.
Enfin, nous calculerons les rendements cumulés de notre stratégie en appliquant la méthode cumprod à la colonne Strategy Returns. Cela nous fournira la performance globale de notre stratégie sur la période spécifiée.
À ce stade, nous pouvons visualiser les performances de notre stratégie en traçant les rendements cumulés. Nous utiliserons la bibliothèque matplotlib pour créer un graphique linéaire qui montre la croissance des rendements de notre stratégie au fil du temps.
Dans le graphique, nous pouvons observer la courbe des rendements cumulés, ce qui devrait nous donner une idée de l'efficacité de notre stratégie de momentum. Des rendements cumulés positifs indiquent une rentabilité, tandis que des rendements cumulés négatifs indiquent des pertes.
Gardez à l'esprit qu'il s'agit d'un exemple simplifié de stratégie de trading dynamique et que de nombreux facteurs doivent être pris en compte lors de l'élaboration d'une stratégie de trading dans le monde réel, tels que les coûts de transaction, le glissement et la gestion des risques. Il est important de tester minutieusement et de valider toute stratégie de trading avant de l'appliquer au trading du monde réel.
<Comment utiliser Alpha Vantage Free Real Time Stock API & Python pour extraire l'heure des hauts et des bas quotidiens
Comment utiliser Alpha Vantage Free Real Time Stock API & Python pour extraire l'heure des hauts et des bas quotidiens
Dans cette vidéo, nous allons utiliser un Jupyter Notebook pour explorer l'API Alpha Vantage et extraire les prix de négociation élevés et bas d'une action à l'aide de données de négociation d'une minute. Alpha Vantage est l'une des nombreuses API disponibles pour obtenir des données de trading en temps réel et fonctionne sur un modèle freemium. Pour commencer, nous devrons créer un compte gratuit et obtenir une clé API sur le site Web d'Alpha Vantage.
Nous utiliserons la bibliothèque d'assistance Alpha Vantage appelée "alpha_vantage", qui simplifie le processus d'appels API. Si vous n'avez pas installé la bibliothèque, vous pouvez le faire en exécutant la commande "pip install alpha_vantage" dans votre ligne de commande.
Pour commencer, nous configurons notre environnement en important les bibliothèques tierces nécessaires. Une fois cela fait, nous stockons notre clé API dans une variable. Si vous préférez garder votre clé API privée, vous pouvez la stocker dans un fichier texte séparé et la lire dans votre bloc-notes. Ensuite, nous créons un objet de série chronologique en spécifiant la clé API et le format de sortie souhaité. Dans ce cas, nous choisissons d'utiliser la bibliothèque pandas car elle permet de travailler plus facilement avec les données de sortie, qui sont au format JSON par défaut.
Pour récupérer les données de trading, nous faisons un appel à l'API Alpha Vantage en utilisant la fonction "get_intraday". Cette fonction nous permet de spécifier le symbole du stock et l'intervalle souhaité, comme une minute, cinq minutes ou une heure. Nous pouvons également définir la taille de sortie, qui détermine la quantité de données historiques que nous voulons récupérer. Pour cette vidéo, nous l'avons défini sur "complet", ce qui nous donne environ dix jours de données.
Une fois que nous avons récupéré les données, nous pouvons examiner les métadonnées qui y sont associées en accédant à l'attribut "meta". Le méta-objet fournit des informations sur les données téléchargées, telles que l'intervalle, la date des données et les colonnes qu'elles contiennent. Nous pouvons ensuite inspecter les données elles-mêmes en appelant la méthode "info", qui affiche les noms des colonnes et l'index date-heure.
Pour obtenir une représentation visuelle des données, nous pouvons tracer l'une des colonnes, comme les cours de clôture. Cependant, les noms de colonne renvoyés par Alpha Vantage peuvent ne pas être pratiques à utiliser, nous pouvons donc les renommer avec des noms plus significatifs.
Ensuite, nous extrayons les données correspondant aux heures normales de négociation, à l'exclusion des échanges après les heures ouvrables, qui peuvent introduire des distorsions. Nous créons une nouvelle variable appelée "marché" en appliquant un filtre temporel aux données. Pandas fournit une fonction pratique, "between_time", qui nous permet de spécifier les heures de début et de fin du marché.
À ce stade, nous sommes prêts à extraire les dates et heures des hauts et des bas. On le fait dans deux façons. Tout d'abord, nous regroupons les données par date de transaction et utilisons la méthode "ag" pour calculer les valeurs minimales et maximales pour les colonnes inférieure et supérieure, respectivement. Cette approche nous donne les valeurs basses et hautes réelles pour chaque jour de bourse.
Deuxièmement, nous adoptons une approche différente et nous concentrons sur la minute où le bas et le haut se sont produits. Nous utilisons la fonction "loc" pour localiser les lignes spécifiques où les bas et les hauts se produisent au cours de chaque jour de bourse. Ensuite, nous extrayons l'index (date et heure) pour les valeurs minimales et maximales, respectivement. Cela nous permet d'identifier la minute exacte où les prix bas et hauts ont été atteints.
En examinant les résultats, nous pouvons observer des modèles intéressants, tels que le moment des bas et des hauts tout au long des jours de bourse.
Cette vidéo fournit un aperçu de base de l'utilisation de l'API Alpha Vantage pour récupérer des données de trading minute par minute et extraire les hauts et les bas pour analyse. Il sert de point de départ pour explorer et utiliser l'API Alpha Vantage dans vos propres projets.
En conclusion, ce didacticiel vidéo montre comment utiliser l'API Alpha Vantage et la bibliothèque d'assistance Alpha Vantage dans un Jupyter Notebook pour extraire les prix de négociation élevés et bas d'une action à l'aide de données de négociation d'une minute. En suivant les étapes décrites dans la vidéo, vous pouvez récupérer des données de trading en temps réel, les analyser à l'aide de pandas et obtenir des informations sur le moment des hauts et des bas au cours d'une journée de trading donnée.
Il est important de noter que l'API Alpha Vantage offre diverses fonctionnalités et options de données au-delà de ce qui a été couvert dans cette vidéo. Vous pouvez explorer différents intervalles, tels que des données de cinq minutes ou d'une heure, ainsi que différents types de données, y compris des données quotidiennes ou historiques. L'API fournit également des fonctionnalités supplémentaires, telles que des indicateurs techniques et des données fondamentales.
Pour améliorer encore votre analyse, vous pouvez incorporer des techniques supplémentaires de manipulation et de visualisation des données. Par exemple, vous pouvez calculer des mesures supplémentaires en fonction des prix élevés et bas extraits, effectuer des analyses statistiques ou créer des visualisations interactives pour présenter les données de manière plus intuitive.
N'oubliez pas de vous reporter à la documentation d'Alpha Vantage pour obtenir des informations détaillées sur les appels d'API, les paramètres et les options disponibles. De plus, assurez-vous de respecter les termes et conditions de l'API Alpha Vantage, y compris toutes les limitations ou restrictions d'utilisation associées à votre compte gratuit.
En tirant parti de l'API Alpha Vantage et en la combinant avec les capacités de Jupyter Notebook et de la bibliothèque pandas, vous pouvez déverrouiller une multitude de données de trading et explorer diverses stratégies et informations pour soutenir vos décisions d'investissement et vos analyses quantitatives.
Introduction aux nuages de points avec matplotlib Python pour la science des données
Introduction aux nuages de points avec matplotlib Python pour la science des données
Ceci est la deuxième vidéo de ma série d'introduction à Matplotlib. Dans cette vidéo, nous allons nous concentrer sur les nuages de points. Les nuages de points sont une aide visuelle qui nous aide à déterminer la force et la nature d'une relation entre deux variables. Nous couvrirons les bases de la création de nuages de points, y compris la définition de thèmes, l'ajout d'une carte de couleurs, la création d'un graphique à bulles et l'ajout de dimensionnalité.
Pour commencer, configurons notre environnement en important les bibliothèques nécessaires. Nous allons importer NumPy, Matplotlib et le lecteur de données Pandas. Le lecteur de données Pandas nous permettra de télécharger des données réelles avec lesquelles travailler. Dans ce cas, nous téléchargerons trois à quatre mois de données pour Google, Amazon et l'ETF or.
Une fois que nous avons les données, nous pouvons jeter un œil aux premières lignes pour nous familiariser avec l'ensemble de données. Nous pouvons voir que les données commencent le 1er août et incluent les cours de clôture.
Maintenant, créons un nuage de points de base en utilisant la méthode de dispersion de Matplotlib. Nous pouvons choisir deux colonnes dans l'ensemble de données et les tracer. Cependant, ce nuage de points de base ne fournit pas beaucoup d'informations sur la relation entre les variables.
Pour approfondir nos recherches, nous pouvons calculer le taux de rendement instantané de chaque titre. Cela nous permettra de mieux comprendre comment les changements de prix sont liés les uns aux autres. Nous supprimons le prix absolu et le réduisons à un pourcentage de variation. En regardant les premières observations, on peut voir que tous les titres ont baissé, Amazon et Google connaissant une baisse de plus de 1%, tandis que l'or est resté relativement inchangé.
Ensuite, nous supprimons la première observation, qui n'est pas un nombre, et traçons un nuage de points pour voir si le changement dans Google est pertinent par rapport au changement dans Amazon. Ce nuage de points raconte une histoire différente de la précédente. Nous pouvons observer une tendance générale selon laquelle à mesure que Google augmente, Amazon augmente également, ce qui indique une forte relation positive entre les deux variables.
Maintenant que nous avons le nuage de points de base, nous pouvons ajouter quelques fonctionnalités pour l'améliorer. Tout d'abord, changeons la taille du tracé pour le rendre plus visible. Nous pouvons le faire en important le module parameters de Matplotlib.
Nous pouvons également ajouter un attrait visuel au nuage de points en ajoutant des lignes de guidage pour montrer le mouvement des points dans différentes directions. En traçant des lignes passant par le zéro sur les axes X et Y, nous pouvons rapidement identifier quand les points se déplacent ensemble, s'éloignent ou dans des directions opposées.
Pour améliorer la visibilité des lignes de guidage, nous pouvons définir leur couleur sur une nuance de gris en utilisant la notation RVB. De plus, nous pouvons définir le style de ligne en pointillés pour un effet visuel différent.
Pour améliorer encore le nuage de points, nous pouvons ajouter un jeu de couleurs. Bien que nous n'ayons pas de troisième variable à représenter, nous pouvons toujours ajouter une carte de couleurs au nuage de points. Nous modifions le code du nuage de points pour inclure la couleur des retours pour Amazon, et nous choisissons la carte des couleurs spectrales. Cette carte de couleurs attribue différentes couleurs aux points en fonction des valeurs des rendements, le rouge représentant les valeurs les plus négatives et le violet les valeurs les plus positives.
Cependant, certains points dans la plage médiane peuvent être difficiles à voir en raison du dégradé de couleurs. Pour résoudre ce problème, nous pouvons changer la couleur des bords des points en noir, ce qui les rend plus distincts.
Pour fournir des informations supplémentaires sur les dégradés de couleurs, nous pouvons ajouter une barre de couleur. La barre de couleur trace une légende qui indique le mappage des couleurs en fonction des retours.
De plus, nous pouvons améliorer l'apparence générale de l'intrigue en appliquant un thème. Nous pouvons utiliser Seaborn comme thème, qui est un wrapper autour de Matplotlib qui fournit un style visuellement attrayant. Ce thème modifie l'arrière-plan et ajoute un quadrillage sans nuire aux données tracées.
Enfin, nous pouvons ajuster les limites de l'intrigue pour centrer les lignes de guidage.
Enfin, nous pouvons ajuster les limites du tracé pour centrer les lignes de guidage et rendre le nuage de points plus équilibré visuellement. Nous pouvons définir les limites de l'axe des x et de l'axe des y sur les valeurs minimales et maximales des retours pour garantir que les lignes de guidage se croisent au centre du tracé. Cet ajustement nous aide à visualiser plus efficacement le mouvement des points par rapport aux lignes directrices.
Maintenant que nous avons apporté ces améliorations, notre nuage de points est plus informatif et visuellement attrayant. Nous pouvons clairement voir la relation entre les retours de Google et d'Amazon, ainsi que la répartition des retours en fonction de la carte des couleurs. Les lignes directrices fournissent une référence visuelle pour interpréter le mouvement des points dans différentes directions.
En plus des nuages de points de base, nous pouvons également créer un graphique à bulles à l'aide de Matplotlib. Un graphique à bulles ajoute une troisième dimension au tracé en faisant varier la taille des marqueurs en fonction d'une troisième variable. Dans notre cas, nous pouvons utiliser le volume de chaque titre comme troisième variable.
Pour créer un graphique à bulles, nous modifions notre code de nuage de points en spécifiant le paramètre de taille et en passant le volume de chaque titre comme taille de marqueur. Cela crée des cercles dont la taille est proportionnelle au volume de chaque titre, ce qui nous permet de visualiser la relation entre les rendements, le volume et le mouvement des points.
En ajoutant cette troisième dimension au nuage de points, nous acquérons une meilleure compréhension de la relation entre les variables. Nous pouvons voir que les cercles plus grands représentent des volumes de transactions plus élevés, et le mouvement des points peut être corrélé à la fois aux rendements et au volume.
En conclusion, les nuages de points et les graphiques à bulles sont de puissants outils de visualisation qui nous aident à comprendre la relation entre les variables. Nous pouvons les utiliser pour analyser et interpréter des données, identifier des modèles et des tendances et prendre des décisions éclairées. Avec Matplotlib, nous pouvons créer des nuages de points personnalisés et visuellement attrayants et les améliorer avec diverses fonctionnalités, telles que des cartes de couleurs, des lignes directrices et des thèmes.
Introduction au trading algorithmique avec Python : créer un algorithme de trading à retour moyen
Introduction au trading algorithmique avec Python : créer un algorithme de trading à retour moyen
Dans cette vidéo, nous allons explorer un algorithme de trading de retour à la moyenne à des fins éducatives uniquement. Il est important de noter que cette vidéo ne fournit pas de conseils en investissement. L'algorithme sera implémenté à l'aide d'un Jupyter Notebook, et un lien pour télécharger le notebook sera fourni dans la description de la vidéo. Cette vidéo sert de compagnon à la stratégie de trading momentum discutée précédemment, et un lien vers cette vidéo sera également fourni.
La stratégie de trading de retour à la moyenne suppose qu'un titre reviendra vers une valeur moyenne chaque fois qu'il s'en écartera trop. Il existe plusieurs façons d'aborder cette stratégie, comme l'utilisation de la régression linéaire ou d'une moyenne mobile. La détermination de "trop loin" et la mesure utilisée peuvent varier. Certaines personnes utilisent une valeur absolue en dollars, alors que dans cette vidéo, nous utiliserons des centiles. De plus, une moyenne mobile sera utilisée pour déterminer la valeur moyenne.
Pour commencer, nous importons les bibliothèques nécessaires, y compris Pandas pour la manipulation de données, Pandas DataReader pour télécharger des données en direct (d'autres services peuvent également être utilisés), NumPy pour les opérations numériques, Matplotlib pour la représentation graphique et Seaborn pour le style des tracés. Les bibliothèques requises sont importées en exécutant la cellule de code correspondante.
Ensuite, nous obtenons les données pour l'analyse. Alors qu'un bon algorithme de trading devrait être généralisable à plusieurs titres, cette vidéo se concentre sur un seul titre : l'ETF sur l'or. Le Pandas DataReader est utilisé pour télécharger environ cinq ans de données pour l'ETF or. Étant donné que seul le cours de clôture est intéressant, nous limitons le téléchargement à cette colonne. Une fois les données obtenues, nous examinons les premières lignes pour nous assurer de leur bonne récupération.
Après avoir obtenu les données, nous ajoutons quelques colonnes au bloc de données. La première colonne ajoutée est pour la moyenne mobile. Nous définissons une variable pour définir la période moyenne mobile, qui peut être facilement manipulée. Le taux de rendement instantané de la clôture de la veille est calculé et stocké dans une nouvelle colonne. Une autre colonne, nommée "moyenne mobile", est créée pour suivre la valeur moyenne basée sur le cours de clôture en utilisant une moyenne sur 21 jours (ou un mois de négociation). De plus, une colonne "ratio" est ajoutée, représentant la division du cours de clôture par la moyenne mobile. Cette colonne permet de déterminer quand le prix est trop éloigné de la moyenne.
Des statistiques descriptives sont calculées pour la colonne "ratio" afin d'avoir un aperçu de la distribution des données. Comme prévu, les prix restent généralement proches de la valeur moyenne. Les 25e et 75e centiles définissent les limites inférieure et supérieure des données, tandis que les valeurs minimales et maximales indiquent des écarts extrêmes par rapport à la moyenne. Des points de prix supplémentaires sont sélectionnés pour analyse, tels que les 5e, 10e, 90e et 95e centiles, afin de déterminer les écarts significatifs par rapport à la moyenne. La fonction numpy percentile est utilisée pour calculer les valeurs respectives en fonction de la colonne "gold ratio". Avant d'effectuer le calcul, les valeurs manquantes sont supprimées.
Pour visualiser le mouvement de la colonne de ratio autour de la moyenne, un tracé est généré. Les valeurs non pertinentes sont supprimées et la colonne de ratio est tracée avec une légende. Des lignes horizontales sont ajoutées pour représenter les conditions de remise aux centiles sélectionnés (5e, 50e et 95e). Cette représentation visuelle aide à observer le mouvement cyclique de la colonne de ratio autour de la moyenne, indiquant une tendance à corriger les écarts.
Ensuite, des seuils spécifiques sont définis pour déterminer quand être court ou long. La position courte est définie comme le 95e centile, tandis que la position longue est définie comme le 5e centile. Une nouvelle colonne est ajoutée au bloc de données, indiquant si la position est longue ou courte. La fonction "où" de Numpy est utilisée pour attribuer des valeurs basées sur la colonne du ratio d'or. Une valeur de -1 est attribuée lorsque le rapport est inférieur au seuil court, indiquant une position courte, et une valeur de 1 est attribuée lorsque le rapport est supérieur au seuil long, indiquant une position longue. Enfin, un graphique est généré pour visualiser les positions. Le graphique affiche la colonne du ratio et met en évidence les positions longues et courtes avec des couleurs différentes.Après avoir identifié les positions, l'étape suivante consiste à calculer les rendements quotidiens. Cela se fait en multipliant la colonne de la position avec la colonne du taux de rendement quotidien, ce qui donne le rendement pour chaque jour en fonction de la position détenue. Une nouvelle colonne nommée "stratégie" est ajoutée au bloc de données pour stocker les rendements quotidiens.
Pour évaluer la performance de la stratégie, des rendements cumulés sont calculés. Les rendements cumulés sont obtenus en prenant le produit cumulé des rendements de la stratégie, en ajoutant 1 au résultat et en multipliant par 100 pour la représentation en pourcentage. Un graphique est généré pour visualiser les rendements cumulés au fil du temps.
Ensuite, des mesures de performance supplémentaires sont calculées pour évaluer les performances de la stratégie. Le rendement total, le rendement quotidien moyen, l'écart type des rendements quotidiens, le ratio de Sharpe et le drawdown maximum sont calculés. Ces mesures fournissent des informations sur la rentabilité, le risque et le rendement ajusté au risque de la stratégie. Les valeurs sont imprimées pour une référence facile.
Enfin, un graphique est généré pour comparer les rendements cumulés de la stratégie de retour à la moyenne avec la stratégie d'achat et de conservation. La stratégie d'achat et de conservation suppose de conserver l'actif pendant toute la période sans aucune décision de négociation. Ce graphique permet une comparaison visuelle des deux stratégies.
En résumé, cette vidéo montre la mise en œuvre d'une stratégie de trading de retour à la moyenne à l'aide de Python et de Jupyter Notebook. Il couvre la récupération des données, le calcul des moyennes mobiles, la détermination des seuils, la visualisation des positions, le calcul des rendements quotidiens, l'évaluation des mesures de performance et la comparaison avec une stratégie d'achat et de conservation. Le Jupyter Notebook fournit un guide étape par étape pour recréer la stratégie et explorer plus avant sa mise en œuvre. N'oubliez pas que cette vidéo est uniquement à des fins éducatives et ne fournit pas de conseils d'investissement.
Pandas Python || Moyennes mobiles et statistiques de fenêtre mobile pour les cours des actions
Pandas Python || Moyennes mobiles et statistiques de fenêtre mobile pour les cours des actions
Dans ce didacticiel vidéo, je vais montrer comment utiliser la méthode de roulement des pandas, qui automatise les calculs des moyennes mobiles et des écarts-types mobiles. La méthode de roulement est un outil puissant pour effectuer des agrégations de fenêtres roulantes, et elle peut être facilement implémentée à l'aide de pandas version 0.21. Je fournirai un lien vers le Jupyter Notebook utilisé dans ce didacticiel à titre de référence.
Pour commencer, nous devons configurer l'environnement. Nous importons la bibliothèque numpy puisque pandas en dépend. Bien que nous n'utilisions pas directement numpy de manière intensive, il est nécessaire que les pandas fonctionnent correctement. De plus, nous importons le lecteur de données pandas pour récupérer les données et matplotlib à des fins de traçage. En utilisant la fonction magique, nous nous assurons que les tracés sont affichés dans le Jupyter Notebook.
Ensuite, nous acquérons les données pour l'analyse. Je vais télécharger les données pour l'or ETF (Exchange-Traded Fund) de Yahoo Finance. Pour préciser le délai souhaité, j'ai fixé la date de début au jour de l'élection présidentielle, il y a environ un an. Pour confirmer que les données ont été correctement récupérées, j'affiche les premières lignes de l'ensemble de données. Puisque nous sommes principalement intéressés par les cours de clôture de cette démonstration, je supprime les autres colonnes. De plus, comme le bloc de données téléchargé est une série de séries et ne possède pas certaines propriétés dont j'ai besoin, je le transforme en bloc de données.
Nous sommes maintenant prêts à démontrer la méthode de roulement. J'ajouterai une nouvelle colonne au bloc de données appelé "MA9" pour représenter la moyenne mobile sur neuf jours. En utilisant la méthode de roulement, je calcule la moyenne pour le nombre spécifié de périodes ou de lignes. Je répète ce processus pour une fenêtre plus longue de 21 jours. Ces deux nouvelles colonnes représentent les moyennes mobiles que nous avons calculées. Pour visualiser les données, je trace les cours de clôture, la moyenne mobile sur neuf jours et la moyenne mobile sur 21 jours.
Parfois, il est utile de décaler les moyennes mobiles. En ajoutant le paramètre "center=True" lors de l'utilisation de la méthode glissante, nous pouvons reculer la ligne de la moyenne mobile de dix jours pour la fenêtre de 21 jours. Cela crée une ligne décalée qui s'aligne sur les données correspondantes. Nous pouvons observer ce décalage dans le graphique tracé.
Je dois noter que lors du calcul des moyennes mobiles, l'observation actuelle est incluse dans la moyenne. Si vous souhaitez l'utiliser comme un outil de prévision traditionnel, vous pouvez déplacer la moyenne mobile vers l'avant. En utilisant la méthode de décalage et en spécifiant un entier positif, nous pouvons décaler la moyenne mobile vers l'avant du nombre de périodes souhaité. Cela garantit que l'observation actuelle n'est pas incluse dans la moyenne.
De plus, la méthode de roulement offre d'autres paramètres, tels que la possibilité de définir n'importe quelle valeur de décalage ou même de décaler la moyenne mobile au premier jour à l'aide d'un nombre entier négatif.
De plus, je montre comment calculer la volatilité historique, souvent utilisée dans la tarification des options. Pour ce faire, nous devons ajouter une autre colonne au bloc de données. En utilisant numpy, je calcule les rendements logarithmiques en divisant les cours de clôture par la clôture de la veille. Le traçage de ces retours affiche un graphique bruyant centré autour de zéro.
Pour obtenir la volatilité historique, nous utilisons un écart type mobile avec une fenêtre de 21 jours, car il y a généralement 21 jours de bourse dans un mois. Ce calcul inclut la vingt et unième observation, donc pour refléter avec précision la volatilité, nous décalons le résultat d'un jour. Cela évite de sous-entendre que nous avons des connaissances futures. Le traçage de la volatilité fournit une représentation plus claire des données et révèle des périodes de volatilité élevée et faible des prix de l'or.
Dans une future vidéo, je couvrirai des techniques d'analyse de prix supplémentaires à l'aide de pandas. J'espère que ce didacticiel a fourni une introduction utile à l'utilisation de la méthode de roulement dans les pandas pour les moyennes mobiles et les écarts-types mobiles.
Analyse quantitative du cours des actions avec Python, pandas, NumPy matplotlib & SciPy
Analyse quantitative du cours des actions avec Python, pandas, NumPy matplotlib & SciPy
Dans cette vidéo, le conférencier présente des méthodes analytiques quantitatives pour analyser les variations du cours des actions. L'objectif principal est de déterminer si la variation du prix de l'action suit une distribution normale, d'identifier tout biais directionnel dans la variation quotidienne et d'évaluer si le mouvement du prix peut être décrit comme une marche aléatoire. L'orateur mentionne l'utilisation d'un bloc-notes Jupyter et fournit un lien pour télécharger le bloc-notes.
L'orateur commence par configurer l'environnement et importer des bibliothèques d'analyse de données telles que NumPy, Pandas et Matplotlib. Ils mentionnent également l'utilisation de la bibliothèque Pandas Data Reader pour télécharger des données en direct à partir de l'API Yahoo. L'orateur récupère ensuite les données de stock pour Amazon, en spécifiant les dates de début et de fin, qui sont par défaut les cinq dernières années de données de prix.
Après avoir obtenu les données, le locuteur examine les premières lignes pour vérifier les informations disponibles. Ils indiquent les colonnes représentant les prix haut, bas, d'ouverture, de clôture, de volume et de clôture ajustés. Puisqu'ils sont principalement intéressés par le cours de clôture, ils discutent de l'option d'utiliser la colonne "clôture" ou "clôture ajustée", cette dernière étant utile pour les actions qui ont subi des scissions. Dans ce cas, puisque la dernière scission d'Amazon remonte à 1999, le choix entre les deux colonnes n'a pas d'importance significative.
Ensuite, l'orateur extrait la colonne des cours de clôture dans une variable distincte et calcule le taux de rendement instantané en utilisant le logarithme de la différence entre les cours de clôture consécutifs. Ils affichent les valeurs résultantes, notant que la première ligne contient une valeur NaN (pas un nombre) car le rendement ne peut pas être calculé pour le premier jour.
L'orateur visualise ensuite le changement de prix quotidien en traçant les données sous forme de graphique linéaire à l'aide de Matplotlib. Ils observent que le changement de prix fluctue considérablement et se regroupe autour de zéro, avec des événements occasionnels importants se produisant de manière imprévisible tout au long de la période de cinq ans. Pour analyser une période spécifique, ils tracent la valeur des données de l'année dernière, qui montre moins de densité mais conserve le même schéma global.
Les statistiques descriptives du mouvement des prix sont obtenues à l'aide de la fonction "décrire" de Pandas. L'orateur évoque la possibilité d'obtenir les statistiques individuellement ou d'utiliser d'autres outils mais trouve la méthode Pandas suffisante à ses fins. Ils présentent également la bibliothèque SciPy et démontrent une autre façon de calculer des statistiques descriptives à l'aide de la fonction "describe" de SciPy stats. Ils mentionnent que certaines valeurs apparaissent comme "NaN" en raison de la gestion des valeurs manquantes dans NumPy et SciPy.
Pour rendre les chiffres plus interprétables, le locuteur multiplie les valeurs par 100 pour les convertir en pourcentages. Cette modification améliore la lisibilité de la sortie sans altérer les données.
Ensuite, l'orateur compare la distribution de la variation quotidienne des prix à un échantillon tiré d'une distribution normale. Ils tracent un histogramme des données de retour d'Amazon et observent qu'il montre une activité significative autour du centre, avec des retours s'étalant vers la gauche et la droite, indiquant des queues plus grosses par rapport à une distribution normale. Ils génèrent ensuite un échantillon de la même taille à partir d'une distribution normale à l'aide du module de statistiques SciPy et le tracent sous forme d'histogramme à côté des données de retour Amazon. L'échantillon de distribution normale apparaît plus squatté et plus uniformément réparti que les données d'Amazon.
Ensuite, le locuteur effectue un test statistique, en particulier un test d'aplatissement, à la fois sur la variable normale et sur les rendements Amazon. Le test d'aplatissement examine si la distribution peut être considérée comme normale, l'hypothèse nulle supposant une distribution normale. La statistique de test et la valeur p sont obtenues, l'orateur expliquant l'interprétation des résultats. Pour la variable normale, la statistique de test est légèrement négative, ce qui n'indique aucune preuve solide contre l'hypothèse nulle. En revanche, pour les retours d'Amazon, la statistique de test est beaucoup plus grande, suggérant un rejet de l'hypothèse nulle et concluant que la variation de prix d'Amazon ne peut pas être décrite comme normalement distribuée.
Pour mieux visualiser la différence, le locuteur modifie l'histogramme en affichant les proportions au lieu des fréquences et dans quelle mesure il s'adapte à la distribution. Pour ce faire, je vais apporter quelques modifications à l'histogramme initial. Au lieu d'afficher les fréquences, j'afficherai les proportions. De cette façon, je peux superposer une courbe normale théorique sur l'histogramme et voir à quel point cela correspond.
Continuons et traçons l'histogramme avec la courbe normale. J'utiliserai le module norm de scipy.stats pour générer la courbe normale, puis je la tracerai sur le même graphique que l'histogramme.
En observant le graphique, nous pouvons voir que l'histogramme des rendements d'Amazon s'écarte considérablement de la forme d'une distribution normale. La distribution a des queues plus épaisses, indiquant une occurrence plus élevée de mouvements de prix extrêmes par rapport à ce que nous attendrions d'une distribution normale. Cela correspond à notre précédente analyse de l'aplatissement, qui indiquait un excès d'aplatissement dans les données de retour d'Amazon.
En conclusion, sur la base des méthodes analytiques quantitatives que nous avons employées, nous pouvons déterminer que la variation du cours de l'action Amazon ne peut pas être décrite comme un phénomène normalement distribué. Les données présentent des caractéristiques telles que l'asymétrie et l'aplatissement excessif, indiquant des écarts par rapport à une distribution normale. Les changements de prix quotidiens sont plus concentrés autour de zéro, avec une occurrence fréquente de mouvements plus importants et imprévisibles. Ces informations sont précieuses pour comprendre la nature du comportement du cours des actions d'Amazon et peuvent être utiles pour développer des stratégies d'investissement ou des approches de gestion des risques.
Techniques de modèle de régression linéaire avec Python, NumPy, pandas et Seaborn
Techniques de modèle de régression linéaire avec Python, NumPy, pandas et Seaborn
Dans cette vidéo, nous allons explorer quelques techniques de régression simples en Python. Il existe plusieurs outils disponibles pour implémenter la régression en Python, mais nous nous concentrerons sur quelques-uns d'entre eux, en particulier en utilisant NumPy. Veuillez noter que ce didacticiel ne se veut pas exhaustif et que nous n'effectuerons aucun test statistique. Nous allons simplement ajuster une ligne et visualiser la sortie.
Vous pouvez télécharger le bloc-notes à partir du lien fourni dans la description de la vidéo sur GitHub pour suivre. Commençons par configurer notre environnement et importer les bibliothèques nécessaires. Nous utiliserons NumPy, pandas, Yahoo Finance API pour récupérer des données en direct, matplotlib pour la visualisation et seaborn pour appliquer un thème à nos parcelles.
Ensuite, nous devons récupérer les données. Nous obtiendrons des données pour Google et l'ETF S&P 500, remontant à environ un an. Nous utiliserons le lecteur de données pandas et l'API Yahoo Finance à cette fin. Une fois que nous avons les données, nous pouvons y jeter un coup d'œil rapide. Étant donné que nous ne nous intéressons qu'aux prix "de clôture" pour notre analyse, nous ajusterons les données en conséquence.
Pour effectuer une régression, nous calculerons le taux de rendement instantané de Google et du S&P 500 ETF. Après avoir supprimé toutes les valeurs non valides, nous sommes prêts à calculer la corrélation entre les deux variables. Nous constatons qu'ils sont fortement corrélés, mais nous n'essaierons pas de déterminer la causalité dans cette analyse. Au lieu de cela, nous considérerons le S&P 500 comme la variable indépendante.
Pour faciliter la visualisation, nous allons échantillonner un plus petit sous-ensemble de points de données. Dans ce cas, nous échantillonnons au hasard 60 retours et observons la corrélation, qui reste similaire à l'ensemble de données global. Nous procédons ensuite à la visualisation des données en traçant un nuage de points avec le S&P 500 sur l'axe des x et Google sur l'axe des y.
Passant à la régression, nous allons ajuster un modèle linéaire à l'aide de la fonction polyfit de NumPy. Nous transmettons les données de l'échantillon, avec le S&P 500 comme variable indépendante et Google comme variable dépendante, ainsi que le degré de notre polynôme (1 pour la régression linéaire simple). Cela nous donne la pente et l'ordonnée à l'origine de la ligne la mieux ajustée, qui peut être interprétée comme la valeur bêta.
Pour tracer la ligne de tendance, nous utilisons la fonction polyvale de NumPy, en passant la régression et la variable indépendante. Nous pouvons superposer cette ligne de tendance sur le nuage de points. De plus, la régression peut être utilisée comme indicateur technique pour prédire les prix futurs. Dans cet exemple, nous régressons les cours de clôture du S&P 500 en fonction du temps.
Après avoir obtenu les coefficients de régression, nous pouvons calculer les valeurs prédites pour les points temporels futurs. Nous traçons les données réelles en fonction du temps, ajoutons la ligne de tendance et créons un canal en ajoutant et en soustrayant un écart type du modèle linéaire. Ce canal fournit une représentation visuelle de l'intervalle de confiance de la prédiction.
Enfin, nous montrons comment faire des prédictions pour des points de temps spécifiques en utilisant le modèle de régression. En créant un objet poly1d avec les coefficients de régression, nous pouvons insérer une valeur (représentant un point dans le temps futur) et obtenir la valeur prédite. Nous mentionnons également brièvement le regplot de Seaborn, qui fournit une autre façon de visualiser le nuage de points avec une ligne de tendance et un intervalle de confiance.
En suivant ce didacticiel, vous pourrez vous familiariser avec la régression linéaire en Python et explorer diverses techniques d'analyse et de prédiction.
Maintenant que nous avons couvert les bases de la régression linéaire en Python, explorons quelques techniques et concepts supplémentaires.
Un aspect important de l'analyse de régression est l'évaluation de la qualité de l'ajustement du modèle. En d'autres termes, dans quelle mesure la droite de régression linéaire représente-t-elle la relation entre les variables ? Diverses mesures statistiques peuvent être utilisées pour évaluer l'ajustement, comme la valeur R au carré, qui indique la proportion de la variance de la variable dépendante qui peut être expliquée par la ou les variables indépendantes.
Pour calculer la valeur R au carré, nous pouvons utiliser la bibliothèque statsmodels en Python. Nous allons importer le module nécessaire et ajuster le modèle de régression linéaire à nos données. Ensuite, nous pouvons extraire la valeur R au carré en utilisant l'attribut rsquared du modèle.
Démontrons cela avec un exemple. Supposons que nous ayons un ensemble de données avec deux variables, X et Y, et que nous voulions ajuster un modèle de régression linéaire pour prédire Y en fonction de X. Nous utiliserons la fonction sm.OLS (Ordinary Least Squares) de la bibliothèque statsmodels pour effectuer la régression analyse.
Tout d'abord, nous importons les modules requis :
print( "R-squared:" , r_squared)La valeur R au carré varie de 0 à 1, 1 indiquant un ajustement parfait. Généralement, une valeur R au carré plus élevée suggère un meilleur ajustement du modèle aux données.En plus de la valeur R au carré, il est également important d'examiner les diagrammes de résidus pour vérifier les modèles ou les tendances qui pourraient indiquer des violations des hypothèses de régression linéaire. Les résidus sont les différences entre les valeurs observées et prédites de la variable dépendante. Un bon modèle de régression linéaire doit avoir des résidus aléatoires et uniformément répartis autour de zéro.
Pour visualiser les résidus, nous pouvons tracer un nuage de points des valeurs prédites par rapport aux résidus. Si le graphique montre un modèle ou un écart systématique par rapport au hasard, cela suggère que le modèle de régression linéaire peut ne pas être approprié pour les données.
Pour créer le tracé résiduel, nous pouvons utiliser la bibliothèque matplotlib en Python :
En conclusion, la régression linéaire est une technique puissante et largement utilisée pour modéliser la relation entre les variables. En ajustant une ligne de régression aux données, nous pouvons faire des prédictions et obtenir des informations sur la variable dépendante en fonction des variables indépendantes. Il est important d'évaluer la qualité de l'ajustement à l'aide de mesures telles que la valeur R au carré et de vérifier les tracés des résidus pour évaluer la validité du modèle de régression.