In deze blog leer je live datastromen in realtime visualiseren, allemaal binnen het comfort van je favoriete tool, de Jupyter Notebook.
In de meeste projecten hebben dynamische grafieken binnen Jupyter Notebooks handmatige updates nodig; Het kan bijvoorbeeld nodig zijn dat u op 'herladen' drukt om nieuwe gegevens op te halen om de grafieken bij te werken. Dit werkt niet goed voor een snel veranderende sector, inclusief de financiële sector. Denk erover na om cruciale koopindicaties of fraudewaarschuwingen mis te lopen, omdat uw gebruiker op dat moment niet op herladen heeft gedrukt.
Hier laten we u zien hoe u van handmatige updates naar een streaming- of realtime-methode in Jupyter Notebook kunt overstappen, waardoor uw projecten efficiënter en reactiever worden.
Wat is gedekt:
- Realtime visualisatie: Je leert hoe je gegevens tot leven kunt brengen en ziet hoe deze seconde na seconde evolueren, vlak voor je ogen.
- Jupyter Notebook-beheersing: Benut de volledige kracht van Jupyter Notebook, niet alleen voor statische data-analyse, maar ook voor dynamische, streaming data.
- Python in Quant Finance-gebruiksscenario: Duik in een praktische financiële toepassing, waarbij u een veelgebruikte financiële toepassing implementeert met gegevens uit de echte wereld.
- Streamgegevensverwerking: Begrijp de basis en voordelen van het in realtime verwerken van gegevens, een vaardigheid die steeds belangrijker wordt in de snelle datawereld van vandaag.
Aan het einde van deze blog weet u hoe u soortgelijke real-time visualisaties zoals hieronder kunt bouwen in uw Jupyter Notebook.
De kern van ons project ligt het concept van stroomverwerking.
Simpel gezegd gaat het bij streamverwerking om het in realtime verwerken en analyseren van gegevens terwijl deze worden gegenereerd. Vergelijk het met Google Maps tijdens een rit in de spits, waar u verkeersupdates live ziet, waardoor directe en efficiënte routewijzigingen mogelijk zijn.
Interessant, aldus de CIO van Goldman Sachs in deze Forbes Podcastis de overstap naar streaming of realtime gegevensverwerking een van de belangrijke trends waar we naartoe gaan.
Het gaat erom de kracht van real-time dataverwerking te combineren met een interactieve en vertrouwde omgeving van Jupyter Notebooks.
Daarnaast spelen Jupyter Notebooks goed met containeromgevingen. Daarom blijven onze projecten niet alleen op lokale machines hangen; we kunnen ze overal mee naartoe nemen en ze soepel laten draaien op alles, van de laptop van een collega tot een cloudserver.
In de financiële sector telt elke seconde, of het nu gaat om fraudedetectie of handel, en daarom is de verwerking van stroomgegevens essentieel geworden. De schijnwerpers staan hier op Bollinger Bands, een hulpmiddel dat nuttig is voor financiële handel. Dit hulpmiddel omvat:
- De middelste band: Dit is een voortschrijdend gemiddelde over 20 perioden, dat de gemiddelde aandelenkoers over de afgelopen 20 perioden berekent (zoals 20 minuten voor hoogfrequente analyse), waardoor een momentopname wordt gegeven van de recente prijsontwikkelingen.
- Buitenbanden: Gelegen op twee standaarddeviaties boven en onder de middelste band, duiden ze op marktvolatiliteit; bredere banden duiden op meer volatiliteit, en smallere banden op minder.
In Bollinger Bands worden mogelijk overboughtcondities gesignaleerd wanneer de voortschrijdende gemiddelde prijs de bovenste band raakt of overschrijdt (een signaal om te verkopen, vaak rood gemarkeerd), en oververkochte omstandigheden worden aangegeven wanneer de prijs onder de onderste band zakt (een signaal om te kopen). , meestal groen gemarkeerd).
Algohandelaren koppelen Bollinger Bands gewoonlijk aan andere technische indicatoren.
Hier hebben we een essentiële aanpassing gemaakt bij het genereren van onze Bollinger Bands door handelsvolumes te integreren. Traditioneel houden Bollinger Bands geen rekening met het handelsvolume en worden ze uitsluitend berekend op basis van prijsgegevens.
We hebben dus Bollinger Bands aangegeven op een afstand van VWAP ± 2 × VWSTD waarbij:
- VWAP: A Volumegewogen gemiddelde prijs over 1 minuut voor een meer volumegevoelig perspectief.
- VWSTD: vertegenwoordigt een gerichte, Standaardafwijking van 20 minuten, dwz een maatstaf voor marktvolatiliteit.
Technische uitvoering:
- Wij gebruiken tijdelijk schuiframen ('pw.temporal.sliding') om gegevens in segmenten van 20 minuten te analyseren, alsof u een vergrootglas in realtime over de gegevens beweegt.
- wij hebben verloopstukken ('pw.reducers'), die gegevens binnen elk venster verwerken om voor elk venster een bepaalde uitkomst te verkrijgen, dat wil zeggen de standaardafwijkingen in dit geval.
- Veelhoek.io: Aanbieder van realtime en historische marktgegevens. Hoewel je de API zeker kunt gebruiken voor live gegevens, hebben we voor deze demo een aantal gegevens vooraf opgeslagen in een CSV-bestand, waardoor deze gemakkelijk te volgen is zonder dat je een API-sleutel nodig hebt.
- Weg: Een open-source Pythonic-framework voor snelle gegevensverwerking. Het verwerkt zowel batch- (statische) als streaming- (real-time) gegevens.
- bokeh: Bokeh is ideaal voor het maken van dynamische visualisaties en brengt onze streaminggegevens tot leven met boeiende, interactieve grafieken.
- Paneel: Verbetert ons project met realtime dashboardmogelijkheden en werkt samen met Bokeh om onze visualisaties bij te werken zodra er nieuwe datastromen binnenkomen.
Dit omvat zes stappen:
- Pip-installatie uitvoeren voor relevante frameworks en relevante bibliotheken importeren.
- Voorbeeldgegevens ophalen
- De gegevensbron instellen voor berekeningen
- Berekening van de statistieken die essentieel zijn voor Bollinger Bands
- Dashboardcreatie met behulp van Bokeh en Panel
- Het uitvoeren van het run-commando
1. Importeren en instellen
Laten we eerst snel de benodigde componenten installeren.
%%capture --no-display
!pip install pathway
Begin met het importeren van de benodigde bibliotheken. Deze bibliotheken helpen bij gegevensverwerking, visualisatie en het bouwen van interactieve dashboards.
# Importing libraries for data processing, visualization, and dashboard creation
import datetime
import bokeh.models
import bokeh.plotting
import panel
import pathway as pw2. Voorbeeldgegevens ophalen
Download vervolgens de voorbeeldgegevens van GitHub. Deze stap is cruciaal voor de toegang tot onze gegevens voor visualisatie. Hier hebben we de aandelenkoersen van Apple Inc (AAPL) opgehaald.
# 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
Opmerking: Deze tutorial maakt gebruik van een gepubliceerde showcase hier
3. Gegevensbron instellen
Maak een streaminggegevensbron met behulp van het CSV-bestand. Dit simuleert een live datastroom en biedt een praktische manier om met realtime gegevens te werken zonder dat een API-sleutel nodig is wanneer u het project voor de eerste keer bouwt.
# 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"))
Opmerking: Er vindt geen gegevensverwerking onmiddellijk plaats, maar pas aan het einde wanneer we op het run-commando drukken.
4. Berekening van de statistieken die essentieel zijn voor Bollinger Bands
Hier zullen we kort het handelsalgoritme bouwen dat we hierboven hebben besproken. We hebben een dummystroom van de aandelenkoersen van Apple Inc. Om nu Bollinger Bands te maken,
- We berekenen de gewogen standaardafwijking van 20 minuten (VWSTD)
- Het gewogen lopende gemiddelde van de prijzen over 1 minuut (VWAP)
- Sluit je aan bij de twee hierboven.
# 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)
Je kunt het notitieboekje bekijken hier voor een beter begrip van de berekeningen.
5. Dashboards maken
Het is tijd om onze analyse tot leven te brengen met een Bokeh-plot en paneltabelvisualisatie.
# 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
Wanneer u deze cel uitvoert, worden er tijdelijke aanduiding-containers in uw notitieblok gemaakt voor de plot en tabel. Ze worden gevuld met live gegevens zodra de berekening begint.
6. De berekening uitvoeren
Alle voorbereidingen zijn voltooid en het is tijd om de gegevensverwerkingsengine te laten draaien.
# Command to start the Pathway data processing engine
%%capture --no-display
pw.run()
Terwijl het dashboard in realtime wordt bijgewerkt, zie je hoe de Bollinger Bands acties activeren: groene markeringen voor kopen en rood voor verkopen, vaak tegen een iets hogere prijs.
Opmerking: U moet pw.run() handmatig uitvoeren nadat de widget is geïnitialiseerd en zichtbaar is. Meer details vindt u in dit GitHub-probleem hier.
In deze blog begrijpen we Bollinger Bands en nemen we u mee op een reis van het visualiseren van realtime financiële gegevens in Jupyter Notebook. We hebben laten zien hoe je live datastromen kunt omzetten in bruikbare inzichten met behulp van Bollinger Bands en een mix van open-source Pythonic-tools.
De tutorial biedt een praktisch voorbeeld van realtime analyse van financiële gegevens, waarbij gebruik wordt gemaakt van open source voor een end-to-end oplossing, van het ophalen van gegevens tot interactieve dashboards. U kunt soortgelijke projecten maken door:
- Doe dit voor een aandeel naar keuze door live aandelenkoersen op te halen van API's zoals Yahoo Finance, Polygon, Kraken, enz.
- Als u dit doet voor een groep van uw favoriete aandelen, ETF's, enz.
- Gebruikmaken van een ander handelsinstrument dan Bollinger Bands.
Door deze instrumenten te integreren met realtime gegevens in een Jupyter Notebook, analyseert u niet alleen de markt, maar ervaart u deze ook terwijl deze zich ontvouwt.
Veel plezier met streamen!
Mudit Srivastava werkt bij Pathway Daarvoor was hij een van de oprichters van AI Planet en is hij een actieve communitybuilder op het gebied van LLM's en Real-time ML.
- Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
- PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
- PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
- PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
- Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
- Bron: 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
