I den här bloggen kommer du att lära dig att visualisera livedataströmmar i realtid, allt inom bekvämligheten av ditt favoritverktyg, Jupyter Notebook.
I de flesta projekt behöver dynamiska diagram inom Jupyter Notebooks manuella uppdateringar; till exempel kan det krävas att du trycker på reload för att hämta ny data för att uppdatera diagrammen. Detta fungerar inte bra för alla snabba branscher, inklusive finans. Överväg att gå miste om viktiga köpindikationer eller bedrägerivarningar eftersom din användare inte tryckte på reload vid det tillfället.
Här visar vi dig hur du går från manuella uppdateringar till en streaming- eller realtidsmetod i Jupyter Notebook, vilket gör dina projekt mer effektiva och reaktiva.
Vad som omfattas:
- Realtidsvisualisering: Du kommer att lära dig hur du väcker data till liv och ser den utvecklas sekund för sekund, mitt framför dina ögon.
- Jupyter Notebook Mastery: Utnyttja den fulla kraften hos Jupyter Notebook, inte bara för statisk dataanalys utan för dynamisk, strömmande data.
- Python i Quant Finance Användningsfall: Dyk in i en praktisk finansiell tillämpning, implementera en allmänt använd inom finans med verkliga data.
- Strömdatabearbetning: Förstå grunderna och fördelarna med att behandla data i realtid, en färdighet som blir allt viktigare i dagens snabba datavärld.
I slutet av den här bloggen kommer du att veta hur du bygger liknande realtidsvisualiseringar som den nedan i din Jupyter Notebook.
I hjärtat av vårt projekt ligger konceptet strömbearbetning.
Enkelt uttryckt handlar strömbehandling om att hantera och analysera data i realtid när den genereras. Tänk på det som Google Maps under en rusningstid, där du ser trafikuppdateringar live, vilket möjliggör omedelbara och effektiva ruttändringar.
Intressant nog, enligt CIO för Goldman Sachs i detta Forbes podcast, att gå mot ström eller realtidsdatabehandling är en av de betydande trenderna vi är på väg mot.
Det handlar om att kombinera kraften i realtidsdatabehandling med en interaktiv och välbekant miljö med Jupyter Notebooks.
Förutom det spelar Jupyter Notebooks bra med containeriserade miljöer. Därför har våra projekt inte bara fastnat på lokala maskiner; vi kan ta dem överallt – köra dem smidigt på allt från en kollegas bärbara dator till en molnserver.
Inom ekonomi räknas varje sekund, oavsett om det gäller bedrägeriupptäckt eller handel, och det är därför strömdatabehandling har blivit viktig. Strålkastaren här är tänd Bollinger Bands, ett verktyg som är användbart för finansiell handel. Detta verktyg innehåller:
- Mellanbandet: Detta är ett 20-periods glidande medelvärde, som beräknar den genomsnittliga aktiekursen under de senaste 20 perioderna (som 20 minuter för högfrekvensanalys), vilket ger en ögonblicksbild av de senaste kurstrenderna.
- Yttre band: Ligger 2 standardavvikelser över och under mittbandet indikerar de marknadsvolatilitet – bredare band tyder på mer volatilitet och smalare band, mindre.
I Bollinger Bands signaleras potentiella överköpta förhållanden när det glidande genomsnittspriset vidrör eller överstiger det övre bandet (en signal att sälja, ofta markerad med rött), och översålda förhållanden indikeras när priset faller under det nedre bandet (en signal att köpa , vanligtvis markerad med grönt).
Algo-handlare parar vanligtvis Bollinger Bands med andra tekniska indikatorer.
Här gjorde vi en viktig tweak samtidigt som vi genererade våra Bollinger Bands genom att integrera handelsvolymer. Traditionellt tar Bollinger Bands inte hänsyn till handelsvolym och beräknas enbart baserat på prisdata.
Således har vi indikerat Bollinger-band på ett avstånd av VWAP ± 2 × VWSTD där:
- VWAP: A 1 minuts volymvägt genomsnittspris för ett mer volymkänsligt perspektiv.
- VWSTD: Representerar en fokuserad, 20 minuters standardavvikelse, dvs ett mått på marknadsvolatilitet.
Tekniskt genomförande:
- Vi använder temporal skjutbara fönster ('pw.temporal.sliding') för att analysera data i 20-minuterssegment, liknande att flytta ett förstoringsglas över data i realtid.
- Vi anställer reducerare ('pw.reducers'), som behandlar data inom varje fönster för att ge ett visst resultat för varje fönster, dvs standardavvikelserna i detta fall.
- Polygon.io: Leverantör av realtids- och historisk marknadsdata. Även om du säkert kan använda dess API för livedata, har vi sparat en del data i en CSV-fil för denna demo, vilket gör det enkelt att följa utan att behöva en API-nyckel.
- pathway: Ett Pythonic-ramverk med öppen källkod för snabb databehandling. Den hanterar både batch (statisk) och streaming (realtids) data.
- bokeh: Bokeh är idealiskt för att skapa dynamiska visualiseringar och ger liv åt vår strömmande data med engagerande, interaktiva diagram.
- Panel: Förbättrar vårt projekt med instrumentpanelsfunktioner i realtid och arbetar tillsammans med Bokeh för att uppdatera våra visualiseringar när nya dataströmmar kommer in.
Detta omfattar sex steg:
- Utför pip-installation för relevanta ramverk och importerar relevanta bibliotek.
- Hämtar exempeldata
- Ställa in datakällan för beräkning
- Beräknar statistiken som är nödvändig för Bollinger Bands
- Skapa instrumentpanel med Bokeh och panel
- Trycker på körkommandot
1. Importer och inställningar
Låt oss först snabbt installera de nödvändiga komponenterna.
%%capture --no-display
!pip install pathway
Börja med att importera de nödvändiga biblioteken. Dessa bibliotek kommer att hjälpa till med databearbetning, visualisering och att bygga interaktiva instrumentpaneler.
# Importing libraries for data processing, visualization, and dashboard creation
import datetime
import bokeh.models
import bokeh.plotting
import panel
import pathway as pw2. Hämta provdata
Ladda sedan ner exempeldata från GitHub. Detta steg är avgörande för att komma åt vår data för visualisering. Här har vi hämtat Apple Inc (AAPL) aktiekurser.
# 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
Notera: Den här handledningen utnyttjar en publicerad presentation här.
3. Inställning av datakälla
Skapa en strömmande datakälla med CSV-filen. Detta simulerar en livedataström och erbjuder ett praktiskt sätt att arbeta med realtidsdata utan att behöva en API-nyckel när du bygger projektet för första gången.
# 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"))
Notera: Ingen databehandling sker direkt, men i slutet när vi trycker på körkommandot.
4. Beräkna statistik som är nödvändig för Bollinger Bands
Här kommer vi kort att bygga handelsalgoritmen vi diskuterade ovan. Vi har en dummy ström av Apple Inc. aktiekurser. Nu, för att göra Bollinger Bands,
- Vi beräknar den viktade 20-minuters standardavvikelsen (VWSTD)
- Det 1-minuters vägda löpande genomsnittet av priser (VWAP)
- Gå med i de två ovan.
# 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)
Du kan kolla in anteckningsboken här. för en djupare förståelse av beräkningarna.
5. Skapa instrumentpanel
Det är dags att väcka vår analys till liv med en Bokeh-plot och en paneltabellvisualisering.
# 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
När du kör den här cellen skapas platshållarbehållare i din anteckningsbok för plotten och tabellen. De kommer att fyllas med livedata när beräkningen startar.
6. Köra beräkningen
Alla förberedelser är klara och det är dags att köra databehandlingsmotorn.
# Command to start the Pathway data processing engine
%%capture --no-display
pw.run()
När instrumentpanelen uppdateras i realtid kommer du att se hur Bollinger Bands utlöser åtgärder – gröna markörer för köp och röda för försäljning, ofta till ett något högre pris.
Notera: Du bör köra pw.run() manuellt efter att widgeten är initierad och synlig. Du kan hitta mer information i detta GitHub-nummer här..
I den här bloggen förstår vi Bollinger Bands och tar dig genom en resa för att visualisera finansiell data i realtid i Jupyter Notebook. Vi visade hur man omvandlar livedataströmmar till praktiska insikter med Bollinger Bands och en blandning av Pythonic-verktyg med öppen källkod.
Handledningen ger ett praktiskt exempel på finansiell dataanalys i realtid, och utnyttjar öppen källkod för en helhetslösning från datahämtning till interaktiv instrumentpanel. Du kan skapa liknande projekt genom att:
- Gör detta för en aktie som du väljer genom att hämta aktiekurser från API:er som Yahoo Finance, Polygon, Kraken, etc.
- Gör detta för en grupp av dina favoritaktier, ETF:er, etc.
- Utnyttja något annat handelsverktyg förutom Bollinger Bands.
Genom att integrera dessa instrument med realtidsdata i en Jupyter Notebook, analyserar du inte bara marknaden utan upplever den när den utvecklas.
Lycka till med streaming!
Mudit Srivastava jobbar på Pathway. Dessförinnan var han en av grundarna av AI Planet och är en aktiv samhällsbyggare inom domänen LLM och Real-time ML.
- SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
- PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
- PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
- Platoesg. Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
- PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
- Källa: 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
