Dans ce blog, vous apprendrez à visualiser des flux de données en direct en temps réel, le tout dans le confort de votre outil préféré, le Jupyter Notebook.
Dans la plupart des projets, les graphiques dynamiques dans Jupyter Notebooks nécessitent des mises à jour manuelles ; par exemple, vous devrez peut-être appuyer sur recharger pour récupérer de nouvelles données afin de mettre à jour les graphiques. Cela ne fonctionne pas bien dans les secteurs en évolution rapide, y compris la finance. Envisagez de manquer des indications d'achat cruciales ou des alertes de fraude, car votre utilisateur n'a pas appuyé sur recharger à ce moment-là.
Ici, nous allons vous montrer comment passer des mises à jour manuelles à une méthode de streaming ou en temps réel dans Jupyter Notebook, rendant ainsi vos projets plus efficaces et réactifs.
Ce qui est couvert :
- Visualisation en temps réel : Vous apprendrez à donner vie aux données, en les regardant évoluer seconde par seconde, sous vos yeux.
- Maîtrise du bloc-notes Jupyter : Exploitez toute la puissance de Jupyter Notebook, non seulement pour l'analyse de données statiques, mais aussi pour les données dynamiques en streaming.
- Python dans le cas d'utilisation de Quant Finance : Plongez dans une application financière pratique, mettant en œuvre une méthode largement utilisée en finance avec des données du monde réel.
- Traitement des données en flux : Comprendre les fondements et les avantages du traitement des données en temps réel, une compétence qui devient de plus en plus cruciale dans le monde actuel des données, en évolution rapide.
À la fin de ce blog, vous saurez comment créer des visualisations en temps réel similaires à celle ci-dessous dans votre bloc-notes Jupyter.
Au cœur de notre projet se trouve le concept de traitement de flux.
En termes simples, le traitement de flux consiste à gérer et à analyser les données en temps réel au fur et à mesure de leur génération. Pensez-y comme à Google Maps pendant une heure de pointe, où vous voyez les mises à jour du trafic en direct, permettant des changements d'itinéraire immédiats et efficaces.
Fait intéressant, selon le CIO de Goldman Sachs dans ce Forbes Podcast, l'évolution vers le traitement des données en flux ou en temps réel est l'une des tendances importantes vers lesquelles nous nous dirigeons.
Il s'agit de combiner la puissance du traitement des données en temps réel avec un environnement interactif et familier de Jupyter Notebooks.
En plus de cela, les Jupyter Notebooks fonctionnent bien avec les environnements conteneurisés. Par conséquent, nos projets ne sont pas uniquement bloqués sur des machines locales ; nous pouvons les emmener partout, en les exécutant sans problème sur n'importe quel ordinateur, de l'ordinateur portable d'un collègue jusqu'à un serveur cloud.
En finance, chaque seconde compte, que ce soit pour la détection des fraudes ou pour le trading, et c'est pourquoi le traitement des flux de données est devenu incontournable. Ici, les projecteurs sont braqués Bandes de Bollinger, un outil utile pour le trading financier. Cet outil comprend :
- La bande médiane : Il s'agit d'une moyenne mobile sur 20 périodes, qui calcule le cours moyen de l'action au cours des 20 dernières périodes (par exemple 20 minutes pour une analyse à haute fréquence), donnant un aperçu des tendances récentes des prix.
- Bandes extérieures : Situés à 2 écarts-types au-dessus et en dessous de la bande médiane, ils indiquent la volatilité du marché – des bandes plus larges suggèrent plus de volatilité, et des bandes plus étroites, moins.
Dans les bandes de Bollinger, des conditions potentiellement de surachat sont signalées lorsque le prix moyen mobile touche ou dépasse la bande supérieure (un signal de vente, souvent marqué en rouge), et des conditions de survente sont indiquées lorsque le prix descend en dessous de la bande inférieure (un signal d'achat). , généralement marqué en vert).
Les traders Algo associent généralement les bandes de Bollinger à d’autres indicateurs techniques.
Ici, nous avons apporté un ajustement essentiel lors de la génération de nos bandes de Bollinger en intégrant les volumes de transactions. Traditionnellement, les bandes de Bollinger ne tiennent pas compte du volume des transactions et sont calculées uniquement sur la base des données de prix.
Ainsi, nous avons indiqué les bandes de Bollinger à une distance de VWAP ± 2 × VWSTD où :
- VWAP : A Prix moyen pondéré en fonction du volume sur 1 minute pour une perspective plus sensible au volume.
- VWSTD : représente une approche ciblée et Écart type sur 20 minutes, c'est-à-dire une mesure de la volatilité du marché.
Mise en œuvre technique :
- Nous utilisons le temporel fenêtres coulissantes (« pw.temporal.sliding ») pour analyser les données par segments de 20 minutes, ce qui revient à déplacer une loupe sur les données en temps réel.
- Nous employons réducteurs (« pw.reducers »), qui traitent les données dans chaque fenêtre pour produire un résultat particulier pour chaque fenêtre, c'est-à-dire les écarts types dans ce cas.
- Polygone.io : Fournisseur de données de marché historiques et en temps réel. Bien que vous puissiez certainement utiliser son API pour les données en direct, nous avons pré-enregistré certaines données dans un fichier CSV pour cette démo, ce qui la rend facile à suivre sans avoir besoin d'une clé API.
- Sentier: Un framework Pythonic open source pour un traitement rapide des données. Il gère à la fois les données par lots (statiques) et en streaming (en temps réel).
- Bokeh: Idéal pour créer des visualisations dynamiques, Bokeh donne vie à nos données en streaming avec des graphiques attrayants et interactifs.
- Webinars: Améliore notre projet avec des capacités de tableau de bord en temps réel, en travaillant aux côtés de Bokeh pour mettre à jour nos visualisations à mesure que de nouveaux flux de données arrivent.
Cela implique six étapes :
- Effectuer l'installation de pip pour les frameworks pertinents et importer les bibliothèques pertinentes.
- Récupération d'exemples de données
- Configuration de la source de données pour le calcul
- Calcul des statistiques essentielles pour les bandes de Bollinger
- Création de tableaux de bord à l'aide de Bokeh et Panel
- Frapper la commande d'exécution
1. Importations et configuration
Tout d’abord, installons rapidement les composants nécessaires.
%%capture --no-display
!pip install pathway
Commencez par importer les bibliothèques nécessaires. Ces bibliothèques aideront au traitement des données, à la visualisation et à la création de tableaux de bord interactifs.
# Importing libraries for data processing, visualization, and dashboard creation
import datetime
import bokeh.models
import bokeh.plotting
import panel
import pathway as pw2. Récupération d'exemples de données
Ensuite, téléchargez les exemples de données depuis GitHub. Cette étape est cruciale pour accéder à nos données à des fins de visualisation. Ici, nous avons récupéré le cours des actions Apple Inc (AAPL).
# Command to download the sample APPLE INC stock prices extracted via Polygon API and stored in a CSV for ease of review of this notebook.
%%capture --no-display
!wget -nc https://gist.githubusercontent.com/janchorowski/e351af72ecd8d206a34763a428826ab7/raw/ticker.csv
Remarque: Ce tutoriel s'appuie sur une vitrine publiée ici
3. Configuration de la source de données
Créez une source de données de streaming à l'aide du fichier CSV. Cela simule un flux de données en direct, offrant un moyen pratique de travailler avec des données en temps réel sans avoir besoin d'une clé API lors de la première construction du projet.
# Creating a streaming data source from a CSV file
fname = "ticker.csv"
schema = pw.schema_from_csv(fname)
data = pw.demo.replay_csv(fname, schema=schema, input_rate=1000)
# Uncommenting the line below will override the data table defined above and switch the data source to static mode, which is helpful for initial testing
# data = pw.io.csv.read(fname, schema=schema, mode="static")
# Parsing the timestamps in the data
data = data.with_columns(t=data.t.dt.utc_from_timestamp(unit="ms"))
Remarque: Aucun traitement des données n'a lieu immédiatement, mais à la fin lorsque nous appuyons sur la commande d'exécution.
4. Calcul des statistiques essentielles pour les bandes de Bollinger
Ici, nous allons brièvement construire l'algorithme de trading dont nous avons discuté ci-dessus. Nous disposons d’un flux factice des cours des actions d’Apple Inc. Maintenant, pour créer des bandes de Bollinger,
- Nous calculerons l'écart type pondéré sur 20 minutes (VWSTD)
- La moyenne mobile pondérée des prix sur 1 minute (VWAP)
- Rejoignez les deux ci-dessus.
# Calculating the 20-minute rolling statistics for Bollinger Bands
minute_20_stats = (
data.windowby(
pw.this.t,
window=pw.temporal.sliding(
hop=datetime.timedelta(minutes=1),
duration=datetime.timedelta(minutes=20),
),
behavior=pw.temporal.exactly_once_behavior(),
instance=pw.this.ticker,
)
.reduce(
ticker=pw.this._pw_instance,
t=pw.this._pw_window_end,
volume=pw.reducers.sum(pw.this.volume),
transact_total=pw.reducers.sum(pw.this.volume * pw.this.vwap),
transact_total2=pw.reducers.sum(pw.this.volume * pw.this.vwap**2),
)
.with_columns(vwap=pw.this.transact_total / pw.this.volume)
.with_columns(
vwstd=(pw.this.transact_total2 / pw.this.volume - pw.this.vwap**2)
** 0.5
)
.with_columns(
bollinger_upper=pw.this.vwap + 2 * pw.this.vwstd,
bollinger_lower=pw.this.vwap - 2 * pw.this.vwstd,
)
)# Computing the 1-minute rolling statistics
minute_1_stats = (
data.windowby(
pw.this.t,
window=pw.temporal.tumbling(datetime.timedelta(minutes=1)),
behavior=pw.temporal.exactly_once_behavior(),
instance=pw.this.ticker,
)
.reduce(
ticker=pw.this._pw_instance,
t=pw.this._pw_window_end,
volume=pw.reducers.sum(pw.this.volume),
transact_total=pw.reducers.sum(pw.this.volume * pw.this.vwap),
)
.with_columns(vwap=pw.this.transact_total / pw.this.volume)
)# Joining the 1-minute and 20-minute statistics for comprehensive analysis
joint_stats = (
minute_1_stats.join(
minute_20_stats,
pw.left.t == pw.right.t,
pw.left.ticker == pw.right.ticker,
)
.select(
*pw.left,
bollinger_lower=pw.right.bollinger_lower,
bollinger_upper=pw.right.bollinger_upper
)
.with_columns(
is_alert=(pw.this.volume > 10000)
& (
(pw.this.vwap > pw.this.bollinger_upper)
| (pw.this.vwap pw.this.bollinger_lower)
)
)
.with_columns(
action=pw.if_else(
pw.this.is_alert,
pw.if_else(
pw.this.vwap > pw.this.bollinger_upper, "sell", "buy"
),
"hold",
)
)
)
alerts = joint_stats.filter(pw.this.is_alert)
Vous pouvez consulter le cahier ici pour une compréhension plus approfondie des calculs.
5. Création de tableaux de bord
Il est temps de donner vie à notre analyse avec un tracé Bokeh et une visualisation de table Panel.
# Function to create the statistics plot
def stats_plotter(src):
actions = ["buy", "sell", "hold"]
color_map = bokeh.models.CategoricalColorMapper(
factors=actions, palette=("#00ff00", "#ff0000", "#00000000")
)
fig = bokeh.plotting.figure(
height=400,
width=600,
title="20 minutes Bollinger bands with last 1 minute average",
x_axis_type="datetime",
y_range=(188.5, 191),
)
fig.line("t", "vwap", source=src)
band = bokeh.models.Band(
base="t",
lower="bollinger_lower",
upper="bollinger_upper",
source=src,
fill_alpha=0.3,
fill_color="gray",
line_color="black",
)
fig.scatter(
"t",
"vwap",
color={"field": "action", "transform": color_map},
size=10,
marker="circle",
source=src,
)
fig.add_layout(band)
return fig
# Combining the plot and table in a Panel Row
viz = panel.Row(
joint_stats.plot(stats_plotter, sorting_col="t"),
alerts.select(
pw.this.ticker, pw.this.t, pw.this.vwap, pw.this.action
).show(include_id=False, sorters=[{"field": "t", "dir": "desc"}]),
)
viz
Lorsque vous exécutez cette cellule, des conteneurs d'espace réservé sont créés dans votre bloc-notes pour le tracé et le tableau. Ils seront remplis de données en direct une fois le calcul lancé.
6. Exécution du calcul
Tous les préparatifs sont terminés et il est temps de lancer le moteur de traitement des données.
# Command to start the Pathway data processing engine
%%capture --no-display
pw.run()
Au fur et à mesure que le tableau de bord se met à jour en temps réel, vous verrez comment les bandes de Bollinger déclenchent des actions : des marqueurs verts pour l'achat et rouges pour la vente, souvent à un prix légèrement plus élevé.
Remarque: Vous devez exécuter manuellement pw.run() une fois le widget initialisé et visible. Vous pouvez trouver plus de détails dans ce numéro GitHub ici.
Dans ce blog, nous comprenons les bandes de Bollinger et vous guidons dans un parcours de visualisation de données financières en temps réel dans Jupyter Notebook. Nous avons montré comment transformer des flux de données en direct en informations exploitables à l'aide des bandes de Bollinger et d'un mélange d'outils Pythonic open source.
Le didacticiel fournit un exemple pratique d'analyse de données financières en temps réel, tirant parti de l'open source pour une solution de bout en bout, depuis la récupération de données jusqu'aux tableaux de bord interactifs. Vous pouvez créer des projets similaires en :
- Faites cela pour une action de votre choix en récupérant les cours des actions en direct à partir d'API telles que Yahoo Finance, Polygon, Kraken, etc.
- Faites cela pour un groupe de vos actions, ETF, etc. préférés.
- Tirer parti d’un autre outil de trading en dehors des bandes de Bollinger.
En intégrant ces instruments avec des données en temps réel dans un Jupyter Notebook, vous n'analysez pas seulement le marché, mais vous en faites l'expérience au fur et à mesure de son évolution.
Bonne diffusion !
Mudit Srivastava travaille chez Pathway. Avant cela, il était membre fondateur d'AI Planet et est un bâtisseur de communauté actif dans le domaine des LLM et du ML en temps réel.
- Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
- PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
- PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
- PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
- PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
- La source: https://www.kdnuggets.com/python-in-finance-real-time-data-streaming-within-jupyter-notebook?utm_source=rss&utm_medium=rss&utm_campaign=python-in-finance-real-time-data-streaming-within-jupyter-notebook
