I denne bloggen vil du lære å visualisere live datastrømmer i sanntid, alt innen komforten til favorittverktøyet ditt, Jupyter Notebook.
I de fleste prosjekter trenger dynamiske diagrammer i Jupyter Notebooks manuelle oppdateringer; for eksempel kan det kreve at du trykker på nytt for å hente nye data for å oppdatere diagrammene. Dette fungerer ikke bra for enhver fartsfylt bransje, inkludert finans. Vurder å gå glipp av viktige kjøpsindikasjoner eller svindelvarsler fordi brukeren ikke traff reload i det tilfellet.
Her viser vi deg hvordan du går fra manuelle oppdateringer til en streaming- eller sanntidsmetode i Jupyter Notebook, noe som gjør prosjektene dine mer effektive og reaktive.
Hva dekkes:
- Sanntidsvisualisering: Du vil lære hvordan du bringer data til live, og ser dem utvikle seg sekund for sekund, rett foran øynene dine.
- Jupyter Notebook Mestring: Utnytt den fulle kraften til Jupyter Notebook, ikke bare for statisk dataanalyse, men for dynamisk, streaming data.
- Bruksområde for Python i Quant Finance: Dykk ned i en praktisk økonomisk applikasjon, implementer en mye brukt i finans med data fra den virkelige verden.
- Strømdatabehandling: Forstå grunnlaget og fordelene ved å behandle data i sanntid, en ferdighet som blir stadig mer avgjørende i dagens raske dataverden.
På slutten av denne bloggen vil du vite hvordan du bygger lignende sanntidsvisualiseringer som den nedenfor i Jupyter Notebook.
I hjertet av prosjektet vårt ligger konseptet strømbehandling.
Enkelt sagt handler strømbehandling om å håndtere og analysere data i sanntid etter hvert som de genereres. Tenk på det som Google Maps under en rushtidskjøring, der du ser trafikkoppdateringer live, noe som muliggjør umiddelbare og effektive ruteendringer.
Interessant nok, ifølge CIO for Goldman Sachs i denne Forbes podcast, å bevege seg mot strøm- eller sanntidsdatabehandling er en av de betydelige trendene vi er på vei mot.
Det handler om å kombinere kraften til sanntidsdatabehandling med et interaktivt og kjent miljø med Jupyter Notebooks.
Utenom det spiller Jupyter Notebooks godt med containeriserte miljøer. Derfor sitter prosjektene våre ikke bare fast på lokale maskiner; vi kan ta dem med overalt – kjøre dem jevnt på alt fra en kollegas bærbare datamaskin til en skyserver.
I finans teller hvert sekund, enten det er for svindeloppdagelse eller handel, og det er derfor behandling av strømdata har blitt viktig. Søkelyset her er på Bollinger Bands, et verktøy som er nyttig for finansiell handel. Dette verktøyet består av:
- Mellombandet: Dette er et 20-perioders glidende gjennomsnitt, som beregner gjennomsnittlig aksjekurs over de siste 20 periodene (for eksempel 20 minutter for høyfrekvent analyse), og gir et øyeblikksbilde av de siste kurstrendene.
- Ytre bånd: Plassert 2 standardavvik over og under midtbåndet, indikerer de markedsvolatilitet – bredere bånd antyder mer volatilitet, og smalere bånd, mindre.
I Bollinger Bands signaliseres potensielle overkjøpte forhold når den glidende gjennomsnittsprisen berører eller overstiger det øvre båndet (et signal om å selge, ofte merket med rødt), og oversolgte forhold indikeres når prisen faller under det nedre båndet (et signal om å kjøpe , vanligvis merket med grønt).
Algo-handlere parer vanligvis Bollinger Bands med andre tekniske indikatorer.
Her gjorde vi en viktig justering mens vi genererte Bollinger-båndene våre ved å integrere handelsvolumer. Tradisjonelt vurderer ikke Bollinger Bands handelsvolum og beregnes utelukkende basert på prisdata.
Dermed har vi indikert Bollinger-bånd i en avstand på VWAP ± 2 × VWSTD hvor:
- VWAP: A 1 minutt volumveid gjennomsnittspris for et mer volumfølsomt perspektiv.
- VWSTD: Representerer en fokusert, 20-minutters standardavvik, dvs. et mål på markedsvolatilitet.
Teknisk implementering:
- Vi bruker temporal skyvevinduer ('pw.temporal.sliding') for å analysere data i 20-minutters segmenter, i likhet med å flytte et forstørrelsesglass over dataene i sanntid.
- vi ansetter reduksjonsgir ('pw.reducers'), som behandler data innenfor hvert vindu for å gi et bestemt utfall for hvert vindu, dvs. standardavvikene i dette tilfellet.
- Polygon.io: Leverandør av sanntids- og historiske markedsdata. Selv om du absolutt kan bruke API-en for live-data, har vi forhåndslagret noen data i en CSV-fil for denne demoen, noe som gjør det enkelt å følge uten å trenge en API-nøkkel.
- Bane: Et åpen kildekode Pythonic-rammeverk for rask databehandling. Den håndterer både batch (statisk) og streaming (sanntids) data.
- bokeh: Ideell for å lage dynamiske visualiseringer, bringer Bokeh strømmedataene våre til live med engasjerende, interaktive diagrammer.
- Panel: Forbedrer prosjektet vårt med dashbordfunksjoner i sanntid, og jobber sammen med Bokeh for å oppdatere visualiseringene våre etter hvert som nye datastrømmer kommer inn.
Dette innebærer seks trinn:
- Utfører pip-installasjon for relevante rammeverk og importerer relevante biblioteker.
- Henter eksempeldata
- Sette opp datakilden for beregning
- Beregner statistikken som er viktig for Bollinger Bands
- Oppretting av dashbord ved hjelp av Bokeh og panel
- Trykker på kjør-kommandoen
1. Importer og oppsett
Først, la oss raskt installere de nødvendige komponentene.
%%capture --no-display
!pip install pathway
Start med å importere de nødvendige bibliotekene. Disse bibliotekene vil hjelpe til med databehandling, visualisering og bygging av interaktive dashboards.
# Importing libraries for data processing, visualization, and dashboard creation
import datetime
import bokeh.models
import bokeh.plotting
import panel
import pathway as pw2. Henter prøvedata
Last deretter ned eksempeldataene fra GitHub. Dette trinnet er avgjørende for å få tilgang til dataene våre for visualisering. Her har vi hentet aksjekursene for 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
OBS: Denne opplæringen utnytter et utstillingsvindu som er publisert her.
3. Oppsett av datakilde
Opprett en strømmedatakilde ved hjelp av CSV-filen. Dette simulerer en live datastrøm, og tilbyr en praktisk måte å jobbe med sanntidsdata uten å trenge en API-nøkkel mens du bygger prosjektet for første gang.
# 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"))
OBS: Ingen databehandling skjer umiddelbart, men på slutten når vi trykker på kjør-kommandoen.
4. Beregne statistikken som er viktig for Bollinger Bands
Her vil vi kort bygge handelsalgoritmen vi diskuterte ovenfor. Vi har en dummy strøm av aksjekurser i Apple Inc.. Nå, for å lage Bollinger Bands,
- Vi beregner det vektede 20-minutters standardavviket (VWSTD)
- Det 1-minutters veide gjennomsnittet av priser (VWAP)
- Bli med de to over.
# 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 sjekke ut notatboken her. for en dypere forståelse av beregningene.
5. Oppretting av dashbord
Det er på tide å bringe analysen vår til live med en Bokeh-plott og 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 kjører denne cellen, opprettes plassholderbeholdere i notatboken for plottet og tabellen. De vil bli fylt med live-data når beregningen starter.
6. Kjøre beregningen
Alle forberedelsene er fullført, og det er på tide å kjøre databehandlingsmotoren.
# Command to start the Pathway data processing engine
%%capture --no-display
pw.run()
Når dashbordet oppdateres i sanntid, vil du se hvordan Bollinger Bands utløser handlinger – grønne markører for kjøp og røde for salg, ofte til en litt høyere pris.
OBS: Du bør kjøre pw.run() manuelt etter at widgeten er initialisert og synlig. Du kan finne flere detaljer i denne GitHub-utgaven her..
I denne bloggen forstår vi Bollinger Bands og tar deg gjennom en reise med å visualisere økonomiske data i sanntid i Jupyter Notebook. Vi viste hvordan vi kan transformere live datastrømmer til handlingskraftig innsikt ved hjelp av Bollinger Bands og en blanding av åpen kildekode Pythonic-verktøy.
Opplæringen gir et praktisk eksempel på sanntidsanalyse av økonomiske data, og utnytter åpen kildekode for en ende-til-ende-løsning fra datahenting til interaktiv dashboarding. Du kan lage lignende prosjekter ved å:
- Gjør dette for en aksje du ønsker ved å hente aksjekurser fra APIer som Yahoo Finance, Polygon, Kraken, etc.
- Gjør dette for en gruppe av favorittaksjene dine, ETFer, etc.
- Utnytte et annet handelsverktøy bortsett fra Bollinger Bands.
Ved å integrere disse instrumentene med sanntidsdata i en Jupyter Notebook, analyserer du ikke bare markedet, men opplever det mens det utfolder seg.
Lykke til med streaming!
Mudit Srivastava jobber på Pathway. Før dette var han et grunnleggende medlem av AI Planet og er en aktiv samfunnsbygger innen domenet LLMs og Real-time ML.
- SEO-drevet innhold og PR-distribusjon. Bli forsterket i dag.
- PlatoData.Network Vertical Generative Ai. Styrk deg selv. Tilgang her.
- PlatoAiStream. Web3 Intelligence. Kunnskap forsterket. Tilgang her.
- PlatoESG. Karbon, CleanTech, Energi, Miljø, Solenergi, Avfallshåndtering. Tilgang her.
- PlatoHelse. Bioteknologisk og klinisk etterretning. Tilgang her.
- kilde: 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
