In diesem Blog erfahren Sie, wie Sie Live-Datenströme in Echtzeit visualisieren, und das alles bequem mit Ihrem Lieblingstool, dem Jupyter Notebook.
In den meisten Projekten müssen dynamische Diagramme in Jupyter Notebooks manuell aktualisiert werden. Beispielsweise kann es erforderlich sein, dass Sie auf „Neu laden“ klicken, um neue Daten abzurufen und die Diagramme zu aktualisieren. Das funktioniert in keiner schnelllebigen Branche gut, auch nicht im Finanzwesen. Erwägen Sie, wichtige Kaufhinweise oder Betrugswarnungen zu verpassen, weil Ihr Benutzer in diesem Fall nicht auf „Neu laden“ geklickt hat.
Hier zeigen wir Ihnen, wie Sie in Jupyter Notebook von manuellen Updates zu einer Streaming- oder Echtzeitmethode wechseln und so Ihre Projekte effizienter und reaktiver gestalten.
Was ist abgedeckt:
- Echtzeitvisualisierung: Sie erfahren, wie Sie Daten zum Leben erwecken und beobachten, wie sie sich Sekunde für Sekunde direkt vor Ihren Augen weiterentwickeln.
- Beherrschung des Jupyter-Notebooks: Nutzen Sie die volle Leistung von Jupyter Notebook, nicht nur für die statische Datenanalyse, sondern auch für dynamische Streaming-Daten.
- Python im Quant Finance-Anwendungsfall: Tauchen Sie ein in eine praktische Finanzanwendung und implementieren Sie eine im Finanzwesen weit verbreitete Anwendung mit realen Daten.
- Stream-Datenverarbeitung: Verstehen Sie die Grundlagen und Vorteile der Datenverarbeitung in Echtzeit, eine Fähigkeit, die in der heutigen schnelllebigen Datenwelt immer wichtiger wird.
Am Ende dieses Blogs wissen Sie, wie Sie ähnliche Echtzeitvisualisierungen wie die folgende in Ihrem Jupyter-Notebook erstellen.
Im Mittelpunkt unseres Projekts steht das Konzept der Stream-Verarbeitung.
Einfach ausgedrückt geht es bei der Stream-Verarbeitung um die Verarbeitung und Analyse von Daten in Echtzeit, während sie generiert werden. Stellen Sie es sich wie Google Maps während einer Fahrt zur Hauptverkehrszeit vor, wo Sie Verkehrsinformationen live sehen und so sofortige und effiziente Routenänderungen ermöglichen.
Interessanterweise, so der CIO von Goldman Sachs in diesem Forbes PodcastDer Übergang zur Stream- oder Echtzeit-Datenverarbeitung ist einer der bedeutenden Trends, auf die wir zusteuern.
Es geht darum, die Leistungsfähigkeit der Echtzeit-Datenverarbeitung mit einer interaktiven und vertrauten Umgebung von Jupyter Notebooks zu kombinieren.
Darüber hinaus funktionieren Jupyter-Notebooks gut mit Containerumgebungen. Deshalb bleiben unsere Projekte nicht nur auf lokalen Maschinen hängen; Wir können sie überall hin mitnehmen – und sie reibungslos auf allem ausführen, vom Laptop eines Kollegen bis hin zu einem Cloud-Server.
Im Finanzwesen zählt jede Sekunde, sei es bei der Betrugserkennung oder beim Handel, und deshalb ist die Stream-Datenverarbeitung unverzichtbar geworden. Das Rampenlicht hier ist eingeschaltet Bollinger Bands, ein hilfreiches Tool für den Finanzhandel. Dieses Tool umfasst:
- Das Mittelband: Hierbei handelt es sich um einen gleitenden Durchschnitt über 20 Perioden, der den durchschnittlichen Aktienkurs der letzten 20 Perioden berechnet (z. B. 20 Minuten für die Hochfrequenzanalyse) und so einen Überblick über die jüngsten Preistrends gibt.
- Äußere Bänder: Sie liegen zwei Standardabweichungen über und unter dem mittleren Band und weisen auf Marktvolatilität hin – breitere Bänder deuten auf mehr Volatilität hin, schmalere Bänder auf weniger.
Bei Bollinger-Bändern werden potenziell überkaufte Bedingungen signalisiert, wenn der gleitende Durchschnittspreis das obere Band berührt oder überschreitet (ein Hinweis zum Verkauf, oft rot markiert), und überverkaufte Bedingungen werden angezeigt, wenn der Preis unter das untere Band fällt (ein Hinweis zum Kauf). , normalerweise grün markiert).
Algo-Händler kombinieren Bollinger-Bänder normalerweise mit anderen technischen Indikatoren.
Hier haben wir bei der Erstellung unserer Bollinger-Bänder eine wesentliche Änderung vorgenommen, indem wir Handelsvolumina integriert haben. Traditionell berücksichtigen Bollinger-Bänder das Handelsvolumen nicht und werden ausschließlich auf der Grundlage von Preisdaten berechnet.
Daher haben wir Bollinger-Bänder in einem Abstand von VWAP ± 2 × VWSTD angegeben, wobei:
- VWAP: A 1-minütiger volumengewichteter Durchschnittspreis für eine volumensensitivere Perspektive.
- VWSTD: Stellt eine fokussierte, 20-Minuten-Standardabweichung, also ein Maß für die Marktvolatilität.
Technische Umsetzung:
- Wir verwenden zeitlich Schiebefenster ('pw.temporal.sliding') zum Analysieren von Daten in 20-Minuten-Segmenten, ähnlich dem Bewegen einer Lupe über die Daten in Echtzeit.
- Wir stellen an Reduzierstücke („pw.reducers“), die Daten in jedem Fenster verarbeiten, um ein bestimmtes Ergebnis für jedes Fenster zu liefern, in diesem Fall also die Standardabweichungen.
- Polygon.io: Anbieter von Echtzeit- und historischen Marktdaten. Während Sie die API durchaus für Live-Daten verwenden können, haben wir für diese Demo einige Daten vorab in einer CSV-Datei gespeichert, sodass Sie sie leicht nachvollziehen können, ohne dass ein API-Schlüssel erforderlich ist.
- Pathway: Ein Open-Source-Pythonic-Framework für schnelle Datenverarbeitung. Es verarbeitet sowohl Batch- (statische) als auch Streaming-Daten (Echtzeit).
- Bokeh: Bokeh ist ideal für die Erstellung dynamischer Visualisierungen und erweckt unsere Streaming-Daten mit ansprechenden, interaktiven Diagrammen zum Leben.
- Tafel: Erweitert unser Projekt um Echtzeit-Dashboard-Funktionen und arbeitet mit Bokeh zusammen, um unsere Visualisierungen zu aktualisieren, wenn neue Datenströme eingehen.
Dies umfasst sechs Schritte:
- Führen Sie eine Pip-Installation für relevante Frameworks durch und importieren Sie relevante Bibliotheken.
- Beispieldaten werden abgerufen
- Einrichten der Datenquelle für die Berechnung
- Berechnung der für Bollinger-Bänder wesentlichen Statistiken
- Dashboard-Erstellung mit Bokeh und Panel
- Drücken Sie den Ausführungsbefehl
1. Importe und Einrichtung
Lassen Sie uns zunächst schnell die erforderlichen Komponenten installieren.
%%capture --no-display
!pip install pathway
Beginnen Sie mit dem Importieren der erforderlichen Bibliotheken. Diese Bibliotheken helfen bei der Datenverarbeitung, Visualisierung und dem Aufbau interaktiver Dashboards.
# Importing libraries for data processing, visualization, and dashboard creation
import datetime
import bokeh.models
import bokeh.plotting
import panel
import pathway as pw2. Beispieldaten abrufen
Laden Sie als Nächstes die Beispieldaten von GitHub herunter. Dieser Schritt ist entscheidend für den Zugriff auf unsere Daten zur Visualisierung. Hier haben wir die Aktienkurse von Apple Inc (AAPL) abgerufen.
# 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
Hinweis: Dieses Tutorial nutzt einen veröffentlichten Showcase hier
3. Datenquellen-Setup
Erstellen Sie mithilfe der CSV-Datei eine Streaming-Datenquelle. Dies simuliert einen Live-Datenstrom und bietet eine praktische Möglichkeit, mit Echtzeitdaten zu arbeiten, ohne dass beim ersten Erstellen des Projekts ein API-Schlüssel erforderlich ist.
# 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"))
Hinweis: Die Datenverarbeitung erfolgt nicht sofort, sondern am Ende, wenn wir den Befehl „Ausführen“ drücken.
4. Berechnung der für Bollinger-Bänder wesentlichen Statistiken
Hier werden wir kurz den oben besprochenen Handelsalgorithmus aufbauen. Wir haben einen Dummy-Stream der Aktienkurse von Apple Inc. Um nun Bollinger-Bänder zu erstellen,
- Wir berechnen die gewichtete 20-Minuten-Standardabweichung (VWSTD).
- Der 1-minütige gewichtete laufende Durchschnitt der Preise (VWAP)
- Verbinde die beiden oben.
# 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)
Sie können sich das Notizbuch ansehen hier für ein tieferes Verständnis der Berechnungen.
5. Dashboard-Erstellung
Es ist an der Zeit, unsere Analyse mit einem Bokeh-Plot und einer Panel-Tabellenvisualisierung zum Leben zu erwecken.
# 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
Wenn Sie diese Zelle ausführen, werden in Ihrem Notizbuch Platzhaltercontainer für den Plot und die Tabelle erstellt. Sie werden mit Live-Daten gefüllt, sobald die Berechnung beginnt.
6. Ausführen der Berechnung
Alle Vorbereitungen sind abgeschlossen und es ist Zeit, die Datenverarbeitungs-Engine auszuführen.
# Command to start the Pathway data processing engine
%%capture --no-display
pw.run()
Während das Dashboard in Echtzeit aktualisiert wird, können Sie sehen, wie die Bollinger-Bänder Aktionen auslösen – grüne Markierungen für den Kauf und rote für den Verkauf, oft zu einem etwas höheren Preis.
Hinweis: Sie sollten pw.run() manuell ausführen, nachdem das Widget initialisiert und sichtbar ist. Weitere Details finden Sie in dieser GitHub-Ausgabe hier.
In diesem Blog verstehen wir Bollinger-Bänder und nehmen Sie mit auf eine Reise zur Visualisierung von Echtzeit-Finanzdaten im Jupyter Notebook. Wir haben gezeigt, wie man Live-Datenströme mithilfe von Bollinger-Bändern und einer Mischung aus Open-Source-Pythonic-Tools in umsetzbare Erkenntnisse umwandelt.
Das Tutorial bietet ein praktisches Beispiel für die Analyse von Finanzdaten in Echtzeit und nutzt Open Source für eine End-to-End-Lösung vom Datenabruf bis zum interaktiven Dashboarding. Sie können ähnliche Projekte erstellen, indem Sie:
- Tun Sie dies für eine Aktie Ihrer Wahl, indem Sie Live-Aktienkurse von APIs wie Yahoo Finance, Polygon, Kraken usw. abrufen.
- Tun Sie dies für eine Gruppe Ihrer Lieblingsaktien, ETFs usw.
- Nutzung eines anderen Handelsinstruments als der Bollinger-Bänder.
Durch die Integration dieser Instrumente mit Echtzeitdaten in ein Jupyter-Notebook analysieren Sie den Markt nicht nur, sondern erleben ihn, während er sich entwickelt.
Viel Spaß beim Streamen!
Mudit Srivastava arbeitet bei Pathway. Zuvor war er Gründungsmitglied von AI Planet und ist ein aktiver Community-Builder im Bereich LLMs und Echtzeit-ML.
- SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
- PlatoData.Network Vertikale generative KI. Motiviere dich selbst. Hier zugreifen.
- PlatoAiStream. Web3-Intelligenz. Wissen verstärkt. Hier zugreifen.
- PlatoESG. Kohlenstoff, CleanTech, Energie, Umwelt, Solar, Abfallwirtschaft. Hier zugreifen.
- PlatoHealth. Informationen zu Biotechnologie und klinischen Studien. Hier zugreifen.
- Quelle: 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
