In questo blog imparerai a visualizzare flussi di dati in tempo reale, il tutto comodamente dal tuo strumento preferito, Jupyter Notebook.
Nella maggior parte dei progetti, i grafici dinamici all'interno di Jupyter Notebooks necessitano di aggiornamenti manuali; ad esempio, potrebbe essere necessario premere Ricarica per recuperare nuovi dati per aggiornare i grafici. Questo non funziona bene per nessun settore frenetico, compresa la finanza. Considera l'idea di perdere indicazioni di acquisto cruciali o avvisi di frode perché il tuo utente non ha premuto Ricarica in quel momento.
Qui ti mostreremo come passare dagli aggiornamenti manuali a un metodo di streaming o in tempo reale in Jupyter Notebook, rendendo i tuoi progetti più efficienti e reattivi.
Cosa è coperto:
- Visualizzazione in tempo reale: Imparerai come dare vita ai dati, osservandoli evolversi secondo dopo secondo, proprio davanti ai tuoi occhi.
- Padronanza del taccuino Jupyter: Sfrutta tutta la potenza di Jupyter Notebook, non solo per l'analisi dei dati statici ma per i dati dinamici e in streaming.
- Python nel caso d'uso di Quant Finance: Immergiti in un'applicazione finanziaria pratica, implementando un'applicazione ampiamente utilizzata in finanza con dati del mondo reale.
- Elaborazione dei dati in streaming: Comprendere le basi e i vantaggi dell'elaborazione dei dati in tempo reale, un'abilità che sta diventando sempre più cruciale nel frenetico mondo dei dati di oggi.
Entro la fine di questo blog, saprai come creare visualizzazioni in tempo reale simili come quella seguente all'interno del tuo Jupyter Notebook.
Al centro del nostro progetto c'è il concetto di elaborazione del flusso.
In poche parole, l'elaborazione del flusso riguarda la gestione e l'analisi dei dati in tempo reale man mano che vengono generati. Pensalo come Google Maps durante un viaggio nelle ore di punta, dove vedi gli aggiornamenti sul traffico in tempo reale, consentendo modifiche del percorso immediate ed efficienti.
È interessante notare che, secondo il CIO di Goldman Sachs in questo Forbes Podcast, il passaggio all'elaborazione dei dati in streaming o in tempo reale è una delle tendenze significative verso cui siamo diretti.
Si tratta di combinare la potenza dell'elaborazione dei dati in tempo reale con l'ambiente interattivo e familiare di Jupyter Notebooks.
Oltre a ciò, i notebook Jupyter funzionano bene con gli ambienti containerizzati. Pertanto, i nostri progetti non sono solo bloccati sulle macchine locali; possiamo portarli ovunque, eseguirli senza problemi su qualsiasi cosa, dal laptop di un collega a un server cloud.
Nella finanza, ogni secondo conta, sia per il rilevamento delle frodi che per il trading, ed è per questo che l'elaborazione dei dati in streaming è diventata essenziale. I riflettori qui sono accesi Bande di Bollinger, uno strumento utile per il trading finanziario. Questo strumento comprende:
- La fascia media: Si tratta di una media mobile di 20 periodi, che calcola il prezzo medio delle azioni negli ultimi 20 periodi (ad esempio 20 minuti per l'analisi ad alta frequenza), fornendo un'istantanea delle recenti tendenze dei prezzi.
- Bande esterne: Situati 2 deviazioni standard sopra e sotto la banda centrale, indicano la volatilità del mercato: le bande più ampie suggeriscono maggiore volatilità, mentre le bande più strette, meno.
Nelle Bande di Bollinger, le condizioni potenzialmente di ipercomprato vengono segnalate quando la media mobile del prezzo tocca o supera la banda superiore (un segnale di vendita, spesso contrassegnato in rosso), mentre le condizioni di ipervenduto vengono indicate quando il prezzo scende al di sotto della banda inferiore (un segnale di acquisto). , tipicamente contrassegnato in verde).
I trader algoritmici di solito accoppiano le bande di Bollinger con altri indicatori tecnici.
In questo caso, abbiamo apportato una modifica essenziale durante la generazione delle nostre bande di Bollinger integrando i volumi di trading. Tradizionalmente, le Bande di Bollinger non tengono conto del volume degli scambi e vengono calcolate esclusivamente sulla base dei dati sui prezzi.
Pertanto, abbiamo indicato le Bande di Bollinger ad una distanza di VWAP ± 2 × VWSTD dove:
- VWAP: A Prezzo medio ponderato in base al volume su 1 minuto per una prospettiva più sensibile al volume.
- VWSTD: rappresenta un focus focalizzato, Deviazione standard di 20 minuti, cioè una misura della volatilità del mercato.
Implementazione tecnica:
- Usiamo temporale finestre scorrevoli ("pw.temporal.sliding") per analizzare i dati in segmenti di 20 minuti, come spostare una lente di ingrandimento sui dati in tempo reale.
- Impieghiamo riduttori ("pw.reducers"), che elaborano i dati all'interno di ciascuna finestra per produrre un risultato particolare per ciascuna finestra, ovvero le deviazioni standard in questo caso.
- Polygon.io: Fornitore di dati di mercato storici e in tempo reale. Anche se puoi sicuramente utilizzare la sua API per i dati in tempo reale, abbiamo pre-salvato alcuni dati in un file CSV per questa demo, rendendolo facile da seguire senza bisogno di una chiave API.
- percorso: Un framework Pythonic open source per l'elaborazione rapida dei dati. Gestisce sia dati batch (statici) che streaming (in tempo reale).
- bokeh: Ideale per creare visualizzazioni dinamiche, Bokeh dà vita ai nostri dati in streaming con grafici accattivanti e interattivi.
- Pannello: migliora il nostro progetto con funzionalità di dashboard in tempo reale, lavorando insieme a Bokeh per aggiornare le nostre visualizzazioni man mano che arrivano nuovi flussi di dati.
Ciò comporta sei passaggi:
- Esecuzione dell'installazione pip per framework pertinenti e importazione delle librerie pertinenti.
- Recupero dei dati di esempio
- Impostazione dell'origine dati per il calcolo
- Calcolo delle statistiche essenziali per le bande di Bollinger
- Creazione di dashboard utilizzando Bokeh e Panel
- Colpire il comando di corsa
1. Importazioni e configurazione
Innanzitutto, installiamo rapidamente i componenti necessari.
%%capture --no-display
!pip install pathway
Inizia importando le librerie necessarie. Queste librerie aiuteranno nell'elaborazione dei dati, nella visualizzazione e nella creazione di dashboard interattivi.
# Importing libraries for data processing, visualization, and dashboard creation
import datetime
import bokeh.models
import bokeh.plotting
import panel
import pathway as pw2. Recupero dei dati di esempio
Successivamente, scarica i dati di esempio da GitHub. Questo passaggio è fondamentale per accedere ai nostri dati per la visualizzazione. Qui abbiamo recuperato i prezzi delle azioni 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
Nota: Questo tutorial sfrutta una vetrina pubblicata qui
3. Impostazione dell'origine dati
Crea un'origine dati in streaming utilizzando il file CSV. Questo simula un flusso di dati in tempo reale, offrendo un modo pratico per lavorare con dati in tempo reale senza la necessità di una chiave API durante la creazione del progetto per la prima volta.
# 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"))
Nota: Nessuna elaborazione dei dati avviene immediatamente, ma alla fine quando premiamo il comando Esegui.
4. Calcolo delle statistiche essenziali per le bande di Bollinger
Qui costruiremo brevemente l’algoritmo di trading di cui abbiamo discusso sopra. Abbiamo un flusso fittizio dei prezzi delle azioni Apple Inc.. Ora, per creare le bande di Bollinger,
- Calcoleremo la deviazione standard ponderata di 20 minuti (VWSTD)
- La media mobile ponderata dei prezzi su 1 minuto (VWAP)
- Unisciti ai due sopra.
# 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)
Puoi controllare il taccuino qui per una comprensione più approfondita dei calcoli.
5. Creazione del dashboard
È giunto il momento di dare vita alla nostra analisi con un grafico Bokeh e la visualizzazione della tabella 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
Quando esegui questa cella, nel tuo taccuino vengono creati contenitori segnaposto per la trama e la tabella. Verranno riempiti con dati in tempo reale una volta avviato il calcolo.
6. Esecuzione del calcolo
Tutti i preparativi sono stati completati ed è ora di avviare il motore di elaborazione dati.
# Command to start the Pathway data processing engine
%%capture --no-display
pw.run()
Man mano che il pannello di controllo si aggiorna in tempo reale, vedrai come le Bande di Bollinger attivano le azioni: indicatori verdi per l'acquisto e rossi per la vendita, spesso a un prezzo leggermente più alto.
Nota: Dovresti eseguire manualmente pw.run() dopo che il widget è inizializzato e visibile. Puoi trovare maggiori dettagli in questo numero di GitHub qui.
In questo blog, comprendiamo le bande di Bollinger e ti accompagniamo attraverso un viaggio di visualizzazione dei dati finanziari in tempo reale in Jupyter Notebook. Abbiamo mostrato come trasformare i flussi di dati in tempo reale in informazioni fruibili utilizzando le bande di Bollinger e una combinazione di strumenti Pythonic open source.
Il tutorial fornisce un esempio pratico di analisi dei dati finanziari in tempo reale, sfruttando l'open source per una soluzione end-to-end dal recupero dei dati al dashboarding interattivo. Puoi creare progetti simili:
- Puoi farlo per un titolo a tua scelta recuperando i prezzi delle azioni in tempo reale da API come Yahoo Finance, Polygon, Kraken, ecc.
- Fallo per un gruppo delle tue azioni preferite, ETF, ecc.
- Sfruttare altri strumenti di trading oltre alle bande di Bollinger.
Integrando questi strumenti con dati in tempo reale all'interno di un Jupyter Notebook, non stai solo analizzando il mercato ma sperimentandolo mentre si svolge.
Buona trasmissione!
Mudita Srivastava lavora presso Pathway. In precedenza, è stato membro fondatore di AI Planet ed è un attivo costruttore di comunità nel campo dei LLM e del Real-time ML.
- Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
- PlatoData.Network Generativo verticale Ai. Potenzia te stesso. Accedi qui.
- PlatoAiStream. Intelligenza Web3. Conoscenza amplificata. Accedi qui.
- PlatoneESG. Carbonio, Tecnologia pulita, Energia, Ambiente, Solare, Gestione dei rifiuti. Accedi qui.
- Platone Salute. Intelligence sulle biotecnologie e sulle sperimentazioni cliniche. Accedi qui.
- Fonte: 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
