En este blog, aprenderá a visualizar flujos de datos en vivo en tiempo real, todo desde la comodidad de su herramienta favorita, Jupyter Notebook. 

En la mayoría de los proyectos, los gráficos dinámicos dentro de Jupyter Notebooks necesitan actualizaciones manuales; por ejemplo, es posible que deba presionar recargar para obtener nuevos datos y actualizar los gráficos. Esto no funciona bien para ninguna industria de ritmo rápido, incluidas las finanzas. Considere perderse indicaciones de compra cruciales o alertas de fraude porque su usuario no presionó recargar en ese momento.

Aquí, le mostraremos cómo pasar de las actualizaciones manuales a un método de transmisión o en tiempo real en Jupyter Notebook, haciendo que sus proyectos sean más eficientes y reactivos.

Qué está cubierto:

• Visualización en tiempo real: Aprenderá cómo dar vida a los datos y observar cómo evolucionan segundo a segundo, ante sus ojos.
• Dominio del cuaderno Jupyter: Aproveche toda la potencia de Jupyter Notebook, no solo para el análisis de datos estáticos sino también para la transmisión de datos dinámicos.
• Python en el caso de uso de finanzas cuantitativas: Sumérjase en una aplicación financiera práctica, implementando una herramienta ampliamente utilizada en finanzas con datos del mundo real.
• Procesamiento de datos de transmisión: Comprenda los fundamentos y los beneficios del procesamiento de datos en tiempo real, una habilidad que se vuelve cada vez más crucial en el acelerado mundo de los datos actual.

Al final de este blog, sabrá cómo crear visualizaciones en tiempo real similares a la que se muestra a continuación en su Jupyter Notebook.

En el corazón de nuestro proyecto se encuentra el concepto de procesamiento de flujo. 

En pocas palabras, el procesamiento de flujo consiste en manejar y analizar datos en tiempo real a medida que se generan. Piense en ello como Google Maps durante un viaje en hora pico, donde ve actualizaciones de tráfico en vivo, lo que permite cambios de ruta inmediatos y eficientes.

Curiosamente, según afirma el CIO de Goldman Sachs en este Forbes Podcast, avanzar hacia el procesamiento de datos en tiempo real o en tiempo real es una de las tendencias importantes hacia las que nos dirigimos. 

Se trata de combinar el poder del procesamiento de datos en tiempo real con un entorno interactivo y familiar de Jupyter Notebooks. 

Además de eso, los Jupyter Notebooks funcionan bien con entornos en contenedores. Por lo tanto, nuestros proyectos no sólo están atrapados en máquinas locales; podemos llevarlos a cualquier parte, ejecutándolos sin problemas en cualquier lugar, desde la computadora portátil de un colega hasta un servidor en la nube.

En finanzas, cada segundo cuenta, ya sea para la detección de fraudes o para el comercio, y es por eso que el procesamiento de datos se ha vuelto esencial. El foco aquí está encendido Las Bandas de Bollinger, una herramienta útil para el comercio financiero. Esta herramienta comprende:

• La banda media: Se trata de una media móvil de 20 períodos, que calcula el precio medio de las acciones durante los últimos 20 períodos (por ejemplo, 20 minutos para análisis de alta frecuencia), lo que proporciona una instantánea de las tendencias recientes de los precios.
• Bandas exteriores: Ubicadas a 2 desviaciones estándar por encima y por debajo de la banda media, indican volatilidad del mercado: las bandas más anchas sugieren más volatilidad y las bandas más estrechas, menos.

En las Bandas de Bollinger, las condiciones potencialmente de sobrecompra se indican cuando el precio promedio móvil toca o excede la banda superior (una señal para vender, a menudo marcada en rojo), y las condiciones de sobreventa se indican cuando el precio cae por debajo de la banda inferior (una señal para comprar). , normalmente marcado en verde).

Los comerciantes de algoritmos suelen combinar las bandas de Bollinger con otros indicadores técnicos. 

Aquí, hicimos un ajuste esencial al generar nuestras Bandas de Bollinger mediante la integración de volúmenes de operaciones. Tradicionalmente, las Bandas de Bollinger no consideran el volumen de operaciones y se calculan únicamente en función de datos de precios.

Así, hemos indicado Bandas de Bollinger a una distancia de VWAP ± 2 × VWSTD donde: 

• VWAP: A Precio medio ponderado por volumen de 1 minuto para una perspectiva más sensible al volumen.
• VWSTD: Representa un enfoque, Desviación estándar de 20 minutos, es decir, una medida de la volatilidad del mercado.

Implementación técnica:

• Usamos temporales ventanas correderas ('pw.temporal.sliding') para analizar datos en segmentos de 20 minutos, similar a mover una lupa sobre los datos en tiempo real.
• Empleamos reductores ('pw.reducers'), que procesan datos dentro de cada ventana para producir un resultado particular para cada ventana, es decir, las desviaciones estándar en este caso.

• Polígono.io: Proveedor de datos de mercado históricos y en tiempo real. Si bien ciertamente puedes usar su API para datos en vivo, hemos guardado previamente algunos datos en un archivo CSV para esta demostración, lo que facilita su seguimiento sin necesidad de una clave API.
• Camino: Un marco Pythonic de código abierto para un procesamiento rápido de datos. Maneja datos por lotes (estáticos) y de transmisión (en tiempo real). 
• Bokeh: Ideal para crear visualizaciones dinámicas, Bokeh da vida a nuestros datos de transmisión con gráficos atractivos e interactivos.
• Panel: Mejora nuestro proyecto con capacidades de panel de control en tiempo real, trabajando junto con Bokeh para actualizar nuestras visualizaciones a medida que ingresan nuevos flujos de datos.

Esto implica seis pasos:

1. Realizar la instalación de pip para marcos relevantes e importar bibliotecas relevantes.
2. Obteniendo datos de muestra
3. Configurar la fuente de datos para el cálculo
4. Calcular las estadísticas esenciales para las Bandas de Bollinger
5. Creación de paneles usando Bokeh y Panel
6. Pulsando el comando ejecutar

1. Importaciones y configuración

Primero, instalemos rápidamente los componentes necesarios.

%%capture --no-display
!pip install pathway

Comience importando las bibliotecas necesarias. Estas bibliotecas ayudarán en el procesamiento de datos, la visualización y la creación de paneles interactivos.

# Importing libraries for data processing, visualization, and dashboard creation

import datetime
import bokeh.models
import bokeh.plotting
import panel
import pathway as pw

2. Obteniendo datos de muestra

A continuación, descargue los datos de muestra de GitHub. Este paso es crucial para acceder a nuestros datos para su visualización. Aquí, hemos obtenido los precios de las acciones de 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: Este tutorial aprovecha un escaparate publicado esta página

3. Configuración de la fuente de datos

Cree una fuente de datos de transmisión utilizando el archivo CSV. Esto simula un flujo de datos en vivo, lo que ofrece una forma práctica de trabajar con datos en tiempo real sin necesidad de una clave API mientras se construye el proyecto por primera vez. 

# 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: No se produce ningún procesamiento de datos inmediatamente, sino al final, cuando pulsamos el comando ejecutar.

4. Calcular las estadísticas esenciales para las Bandas de Bollinger

Aquí, construiremos brevemente el algoritmo comercial que discutimos anteriormente. Tenemos un flujo ficticio de los precios de las acciones de Apple Inc. Ahora, para hacer Bandas de Bollinger, 

1. Calcularemos la desviación estándar ponderada de 20 minutos (VWSTD)
2. El promedio móvil ponderado de precios de 1 minuto (VWAP)
3. Únase a los dos anteriores.

# 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)

Puedes consultar el cuaderno. esta página para una comprensión más profunda de los cálculos. 

5. Creación de paneles

Es hora de darle vida a nuestro análisis con un gráfico Bokeh y una visualización de tabla de 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

Cuando ejecuta esta celda, se crean contenedores de marcador de posición en su cuaderno para el gráfico y la tabla. Se llenarán con datos en vivo una vez que comience el cálculo. 

6. Ejecutar el cálculo

Todos los preparativos están completos y es hora de ejecutar el motor de procesamiento de datos.

# Command to start the Pathway data processing engine
%%capture --no-display
pw.run()

A medida que el panel se actualiza en tiempo real, verá cómo las Bandas de Bollinger activan acciones: marcadores verdes para comprar y rojos para vender, a menudo a un precio ligeramente más alto. 

Nota: Debe ejecutar pw.run() manualmente después de que el widget esté inicializado y visible. Puedes encontrar más detalles en esta edición de GitHub. esta página.

En este blog, entendemos las Bandas de Bollinger y lo llevamos a través de un viaje para visualizar datos financieros en tiempo real en Jupyter Notebook. Mostramos cómo transformar flujos de datos en vivo en información procesable utilizando Bollinger Bands y una combinación de herramientas Pythonic de código abierto.

El tutorial proporciona un ejemplo práctico de análisis de datos financieros en tiempo real, aprovechando el código abierto para una solución de extremo a extremo, desde la obtención de datos hasta el panel interactivo. Puede crear proyectos similares mediante:

• Haga esto para una acción de su elección obteniendo precios de acciones en vivo de API como Yahoo Finance, Polygon, Kraken, etc.
• Haciendo esto para un grupo de sus acciones, ETF, etc. favoritos. 
• Aprovechar alguna otra herramienta comercial además de las Bandas de Bollinger.

Al integrar estos instrumentos con datos en tiempo real dentro de un Jupyter Notebook, no solo analiza el mercado sino que lo experimenta a medida que se desarrolla. 

¡Feliz transmisión!
 
 

Mudit Srivastava Trabaja en Camino. Antes de esto, fue miembro fundador de AI Planet y es un creador de comunidades activo en el ámbito de los LLM y el aprendizaje automático en tiempo real.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• PlatoSalud. Inteligencia en Biotecnología y Ensayos Clínicos. Accede Aquí.
• Fuente: 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