Logotipo de Zephyrnet

Inteligencia de datos generativa

Big Data

Dominar la dinámica del mercado: Transformar el análisis de costos de transacción con Tick History ultrapreciso: PCAP y Amazon Athena para Apache Spark | Servicios web de Amazon

Reeditado por Platón
Reeditado por Platón

Fecha:

Vistas: 146

Esta publicación está coescrita con Pramod Nayak, LakshmiKanth Mannem y Vivek Aggarwal del Low Latency Group de LSEG.

El análisis de costos de transacción (TCA) es ampliamente utilizado por comerciantes, administradores de carteras y corredores para análisis previos y posteriores a la negociación, y les ayuda a medir y optimizar los costos de transacción y la efectividad de sus estrategias comerciales. En esta publicación, analizamos los diferenciales de oferta y demanda de opciones desde el Historial de garrapatas de LSEG – PCAP conjunto de datos usando Amazon Athena para Apache Spark. Le mostramos cómo acceder a los datos, definir funciones personalizadas para aplicar a los datos, consultar y filtrar el conjunto de datos y visualizar los resultados del análisis, todo sin tener que preocuparse por configurar la infraestructura o Spark, incluso para conjuntos de datos grandes.

Antecedentes

La Autoridad de Informes de Precios de Opciones (OPRA) actúa como un procesador de información de valores crucial, recopilando, consolidando y difundiendo informes de últimas ventas, cotizaciones e información pertinente para Opciones de EE. UU. Con 18 bolsas de opciones activas en EE. UU. y más de 1.5 millones de contratos elegibles, OPRA desempeña un papel fundamental a la hora de proporcionar datos completos del mercado.

El 5 de febrero de 2024, Securities Industry Automation Corporation (SIAC) actualizará la transmisión OPRA de 48 a 96 canales de multidifusión. Esta mejora tiene como objetivo optimizar la distribución de símbolos y la utilización de la capacidad de la línea en respuesta a la creciente actividad comercial y la volatilidad en el mercado de opciones de EE. UU. SIAC ha recomendado que las empresas se preparen para velocidades de datos máximas de hasta 37.3 GBits por segundo.

A pesar de que la actualización no altera inmediatamente el volumen total de datos publicados, permite a OPRA difundir datos a un ritmo significativamente más rápido. Esta transición es crucial para abordar las demandas del dinámico mercado de opciones.

OPRA se destaca como uno de los feeds más voluminosos, con un pico de 150.4 mil millones de mensajes en un solo día en el tercer trimestre de 3 y un requisito de capacidad de 2023 mil millones de mensajes en un solo día. Captar cada mensaje es fundamental para el análisis de costos de transacción, el monitoreo de la liquidez del mercado, la evaluación de estrategias comerciales y la investigación de mercado.

Acerca de los datos

Historial de garrapatas de LSEG – PCAP es un repositorio basado en la nube, que supera los 30 PB y que alberga datos del mercado global de altísima calidad. Estos datos se capturan meticulosamente directamente dentro de los centros de datos de Exchange, empleando procesos de captura redundantes ubicados estratégicamente en los principales centros de datos de Exchange primarios y de respaldo en todo el mundo. La tecnología de captura de LSEG garantiza la captura de datos sin pérdidas y utiliza una fuente de tiempo GPS para una precisión de marca de tiempo de nanosegundos. Además, se emplean técnicas sofisticadas de arbitraje de datos para llenar sin problemas cualquier laguna de datos. Después de la captura, los datos se someten a un procesamiento y arbitraje meticulosos y luego se normalizan al formato Parquet utilizando Ultra directo en tiempo real de LSEG (RTUD) manipuladores de alimentos.

El proceso de normalización, que es fundamental para preparar los datos para el análisis, genera hasta 6 TB de archivos Parquet comprimidos por día. El enorme volumen de datos se atribuye a la naturaleza integral de OPRA, que abarca múltiples intercambios y presenta numerosos contratos de opciones caracterizados por diversos atributos. La mayor volatilidad del mercado y la actividad de creación de mercado en las bolsas de opciones contribuyen aún más al volumen de datos publicados en OPRA.

Los atributos de Tick History – PCAP permiten a las empresas realizar varios análisis, incluidos los siguientes:

  • Análisis previo a la negociación – Evaluar el impacto comercial potencial y explorar diferentes estrategias de ejecución basadas en datos históricos
  • Evaluación post-negociación – Medir los costos de ejecución reales frente a puntos de referencia para evaluar el desempeño de las estrategias de ejecución.
  • Optimizado ejecución – Ajustar las estrategias de ejecución basadas en patrones históricos del mercado para minimizar el impacto en el mercado y reducir los costos comerciales generales.
  • Gestión del riesgo – Identificar patrones de deslizamiento, identificar valores atípicos y gestionar proactivamente los riesgos asociados con las actividades comerciales.
  • Atribución de desempeño – Separar el impacto de las decisiones comerciales de las decisiones de inversión al analizar el rendimiento de la cartera.

El conjunto de datos LSEG Tick History – PCAP está disponible en Intercambio de datos de AWS y se puede acceder en AWS Marketplace. Con Intercambio de datos de AWS para Amazon S3, puede acceder a los datos PCAP directamente desde LSEG Servicio de almacenamiento simple de Amazon (Amazon S3), eliminando la necesidad de que las empresas almacenen su propia copia de los datos. Este enfoque agiliza la gestión y el almacenamiento de datos, brindando a los clientes acceso inmediato a PCAP de alta calidad o datos normalizados con facilidad de uso, integración y ahorros sustanciales en almacenamiento de datos.

Atenea para Apache Spark

Para esfuerzos analíticos, Atenea para Apache Spark ofrece una experiencia de computadora portátil simplificada a la que se puede acceder a través de la consola de Athena o las API de Athena, lo que le permite crear aplicaciones Apache Spark interactivas. Con un tiempo de ejecución de Spark optimizado, Athena ayuda al análisis de petabytes de datos al escalar dinámicamente la cantidad de motores Spark en menos de un segundo. Además, las bibliotecas comunes de Python, como pandas y NumPy, se integran perfectamente, lo que permite la creación de una lógica de aplicación compleja. La flexibilidad se extiende a la importación de bibliotecas personalizadas para usar en cuadernos. Athena for Spark se adapta a la mayoría de los formatos de datos abiertos y se integra perfectamente con el Pegamento AWS Catálogo de datos.

Conjunto de datos

Para este análisis, utilizamos el conjunto de datos LSEG Tick History – PCAP OPRA del 17 de mayo de 2023. Este conjunto de datos consta de los siguientes componentes:

  • Mejor oferta y oferta (BBO) – Informa la oferta más alta y la demanda más baja de un valor en un intercambio determinado
  • Mejor oferta y oferta nacional (NBBO) – Informa la oferta más alta y la demanda más baja de un valor en todos los intercambios.
  • Vientos alisios – Registra las operaciones completadas en todos los intercambios

El conjunto de datos involucra los siguientes volúmenes de datos:

  • Vientos alisios – 160 MB distribuidos en aproximadamente 60 archivos Parquet comprimidos
  • BBO – 2.4 TB distribuidos en aproximadamente 300 archivos Parquet comprimidos
  • NBBO – 2.8 TB distribuidos en aproximadamente 200 archivos Parquet comprimidos

Descripción general del análisis

El análisis de los datos del historial de ticks de OPRA para el análisis de costos de transacción (TCA) implica examinar las cotizaciones del mercado y las operaciones en torno a un evento comercial específico. Utilizamos las siguientes métricas como parte de este estudio:

  • Spread cotizado (QS) – Calculado como la diferencia entre la demanda de BBO y la oferta de BBO.
  • Spread efectivo (ES) – Calculado como la diferencia entre el precio comercial y el punto medio del BBO (BBO oferta + (BBO demanda – BBO oferta)/2)
  • Spread efectivo/cotizado (EQF) – Calculado como (ES/QS) * 100

Calculamos estos diferenciales antes de la operación y, además, en cuatro intervalos después de la operación (justo después, 1 segundo, 10 segundos y 60 segundos después de la operación).

Configurar Athena para Apache Spark

Para configurar Athena para Apache Spark, complete los siguientes pasos:

  1. En la consola de Athena, debajo ¡Empieza aquí!, seleccione Analice sus datos usando PySpark y Spark SQL.
  2. Si es la primera vez que utiliza Athena Spark, elija Crear grupo de trabajo.
  3. Nombre del grupo de trabajo¸ introduzca un nombre para el grupo de trabajo, como por ejemplo tca-analysis.
  4. En Motor de análisis sección, seleccionar Apache Spark.
  5. En Configuraciones adicionales sección, puedes elegir Usar valores predeterminados o proporcionar una costumbre Gestión de identidades y accesos de AWS (IAM) y ubicación de Amazon S3 para los resultados del cálculo.
  6. Elige Crear grupo de trabajo.
  7. Después de crear el grupo de trabajo, navegue hasta el Cuadernos pestaña y elegir Crear cuaderno.
  8. Introduzca un nombre para su cuaderno, como tca-analysis-with-tick-history.
  9. Elige Crear para crear tu cuaderno.

Inicie su cuaderno

Si ya ha creado un grupo de trabajo Spark, seleccione Iniciar el editor de cuadernos bajo ¡Empieza aquí!.


Una vez creada su libreta, será redirigido al editor de libreta interactivo.


Ahora podemos agregar y ejecutar el siguiente código en nuestro cuaderno.

Crear un análisis

Complete los siguientes pasos para crear un análisis:

  • Importar bibliotecas comunes:
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go

  • Cree nuestros marcos de datos para BBO, NBBO y operaciones:
bbo_quote = spark.read.parquet(f"s3://<bucket>/mt=bbo_quote/f=opra/dt=2023-05-17/*")
bbo_quote.createOrReplaceTempView("bbo_quote")
nbbo_quote = spark.read.parquet(f"s3://<bucket>/mt=nbbo_quote/f=opra/dt=2023-05-17/*")
nbbo_quote.createOrReplaceTempView("nbbo_quote")
trades = spark.read.parquet(f"s3://<bucket>/mt=trade/f=opra/dt=2023-05-17/29_1.parquet")
trades.createOrReplaceTempView("trades")

  • Ahora podemos identificar una operación para utilizar en el análisis de costos de transacción:
filtered_trades = spark.sql("select Product, Price,Quantity, ReceiptTimestamp, MarketParticipant from trades")

Obtenemos el siguiente resultado:

+---------------------+---------------------+---------------------+-------------------+-----------------+ 
|Product |Price |Quantity |ReceiptTimestamp |MarketParticipant| 
+---------------------+---------------------+---------------------+-------------------+-----------------+ 
|QQQ 230518C00329000|1.1700000000000000000|10.0000000000000000000|1684338565538021907,NYSEArca|
|QQQ 230518C00329000|1.1700000000000000000|20.0000000000000000000|1684338576071397557,NASDAQOMXPHLX|
|QQQ 230518C00329000|1.1600000000000000000|1.0000000000000000000|1684338579104713924,ISE|
|QQQ 230518C00329000|1.1400000000000000000|1.0000000000000000000|1684338580263307057,NASDAQOMXBX_Options|
|QQQ 230518C00329000|1.1200000000000000000|1.0000000000000000000|1684338581025332599,ISE|
+---------------------+---------------------+---------------------+-------------------+-----------------+

Utilizamos la información comercial resaltada en el futuro para el producto comercial (tp), el precio comercial (tpr) y el tiempo comercial (tt).

  • Aquí creamos una serie de funciones auxiliares para nuestro análisis.
def calculate_es_qs_eqf(df, trade_price):
    df['BidPrice'] = df['BidPrice'].astype('double')
    df['AskPrice'] = df['AskPrice'].astype('double')
    df["ES"] = ((df["AskPrice"]-df["BidPrice"])/2) - trade_price
    df["QS"] = df["AskPrice"]-df["BidPrice"]
    df["EQF"] = (df["ES"]/df["QS"])*100
    return df

def get_trade_before_n_seconds(trade_time, df, seconds=0, groupby_col = None):
    nseconds=seconds*1000000000
    nseconds += trade_time
    ret_df = df[df['ReceiptTimestamp'] < nseconds].groupby(groupby_col).last()
    ret_df['BidPrice'] = ret_df['BidPrice'].astype('double')
    ret_df['AskPrice'] = ret_df['AskPrice'].astype('double')
    ret_df = ret_df.reset_index()
    return ret_df

def get_trade_after_n_seconds(trade_time, df, seconds=0, groupby_col = None):
    nseconds=seconds*1000000000
    nseconds += trade_time
    ret_df = df[df['ReceiptTimestamp'] > nseconds].groupby(groupby_col).first()
    ret_df['BidPrice'] = ret_df['BidPrice'].astype('double')
    ret_df['AskPrice'] = ret_df['AskPrice'].astype('double')
    ret_df = ret_df.reset_index()
    return ret_df

def get_nbbo_trade_before_n_seconds(trade_time, df, seconds=0):
    nseconds=seconds*1000000000
    nseconds += trade_time
    ret_df = df[df['ReceiptTimestamp'] < nseconds].iloc[-1:]
    ret_df['BidPrice'] = ret_df['BidPrice'].astype('double')
    ret_df['AskPrice'] = ret_df['AskPrice'].astype('double')
    return ret_df

def get_nbbo_trade_after_n_seconds(trade_time, df, seconds=0):
    nseconds=seconds*1000000000
    nseconds += trade_time
    ret_df = df[df['ReceiptTimestamp'] > nseconds].iloc[:1]
    ret_df['BidPrice'] = ret_df['BidPrice'].astype('double')
    ret_df['AskPrice'] = ret_df['AskPrice'].astype('double')
    return ret_df

  • En la siguiente función, creamos el conjunto de datos que contiene todas las cotizaciones antes y después de la operación. Athena Spark determina automáticamente cuántas DPU lanzar para procesar nuestro conjunto de datos.
def get_tca_analysis_via_df_single_query(trade_product, trade_price, trade_time):
    # BBO quotes
    bbos = spark.sql(f"SELECT Product, ReceiptTimestamp, AskPrice, BidPrice, MarketParticipant FROM bbo_quote where Product = '{trade_product}';")
    bbos = bbos.toPandas()

    bbo_just_before = get_trade_before_n_seconds(trade_time, bbos, seconds=0, groupby_col='MarketParticipant')
    bbo_just_after = get_trade_after_n_seconds(trade_time, bbos, seconds=0, groupby_col='MarketParticipant')
    bbo_1s_after = get_trade_after_n_seconds(trade_time, bbos, seconds=1, groupby_col='MarketParticipant')
    bbo_10s_after = get_trade_after_n_seconds(trade_time, bbos, seconds=10, groupby_col='MarketParticipant')
    bbo_60s_after = get_trade_after_n_seconds(trade_time, bbos, seconds=60, groupby_col='MarketParticipant')
    
    all_bbos = pd.concat([bbo_just_before, bbo_just_after, bbo_1s_after, bbo_10s_after, bbo_60s_after], ignore_index=True, sort=False)
    bbos_calculated = calculate_es_qs_eqf(all_bbos, trade_price)

    #NBBO quotes
    nbbos = spark.sql(f"SELECT Product, ReceiptTimestamp, AskPrice, BidPrice, BestBidParticipant, BestAskParticipant FROM nbbo_quote where Product = '{trade_product}';")
    nbbos = nbbos.toPandas()

    nbbo_just_before = get_nbbo_trade_before_n_seconds(trade_time,nbbos, seconds=0)
    nbbo_just_after = get_nbbo_trade_after_n_seconds(trade_time, nbbos, seconds=0)
    nbbo_1s_after = get_nbbo_trade_after_n_seconds(trade_time, nbbos, seconds=1)
    nbbo_10s_after = get_nbbo_trade_after_n_seconds(trade_time, nbbos, seconds=10)
    nbbo_60s_after = get_nbbo_trade_after_n_seconds(trade_time, nbbos, seconds=60)

    all_nbbos = pd.concat([nbbo_just_before, nbbo_just_after, nbbo_1s_after, nbbo_10s_after, nbbo_60s_after], ignore_index=True, sort=False)
    nbbos_calculated = calculate_es_qs_eqf(all_nbbos, trade_price)

    calc = pd.concat([bbos_calculated, nbbos_calculated], ignore_index=True, sort=False)
    
    return calc

  • Ahora llamemos a la función de análisis TCA con la información de nuestra operación seleccionada:
tp = "QQQ 230518C00329000"
tpr = 1.16
tt = 1684338579104713924
c = get_tca_analysis_via_df_single_query(tp, tpr, tt)

Visualice los resultados del análisis.

Ahora creemos los marcos de datos que usamos para nuestra visualización. Cada marco de datos contiene citas para uno de los cinco intervalos de tiempo para cada fuente de datos (BBO, NBBO):

bbo = c[c['MarketParticipant'].isin(['BBO'])]
bbo_bef = bbo[bbo['ReceiptTimestamp'] < tt]
bbo_aft_0 = bbo[bbo['ReceiptTimestamp'].between(tt,tt+1000000000)]
bbo_aft_1 = bbo[bbo['ReceiptTimestamp'].between(tt+1000000000,tt+10000000000)]
bbo_aft_10 = bbo[bbo['ReceiptTimestamp'].between(tt+10000000000,tt+60000000000)]
bbo_aft_60 = bbo[bbo['ReceiptTimestamp'] > (tt+60000000000)]

nbbo = c[~c['MarketParticipant'].isin(['BBO'])]
nbbo_bef = nbbo[nbbo['ReceiptTimestamp'] < tt]
nbbo_aft_0 = nbbo[nbbo['ReceiptTimestamp'].between(tt,tt+1000000000)]
nbbo_aft_1 = nbbo[nbbo['ReceiptTimestamp'].between(tt+1000000000,tt+10000000000)]
nbbo_aft_10 = nbbo[nbbo['ReceiptTimestamp'].between(tt+10000000000,tt+60000000000)]
nbbo_aft_60 = nbbo[nbbo['ReceiptTimestamp'] > (tt+60000000000)]

En las siguientes secciones, proporcionamos código de ejemplo para crear diferentes visualizaciones.

Trazar QS y NBBO antes del intercambio

Utilice el siguiente código para trazar el diferencial cotizado y el NBBO antes de la operación:

fig = px.bar(title="Quoted Spread Before The Trade",
    x=bbo_bef.MarketParticipant,
    y=bbo_bef['QS'],
    labels={'x': 'Market', 'y':'Quoted Spread'})
fig.add_hline(y=nbbo_bef.iloc[0]['QS'],
    line_width=1, line_dash="dash", line_color="red",
    annotation_text="NBBO", annotation_font_color="red")
%plotly fig

Trazar QS para cada mercado y NBBO después de la operación

Utilice el siguiente código para trazar el diferencial cotizado para cada mercado y NBBO inmediatamente después de la operación:

fig = px.bar(title="Quoted Spread After The Trade",
    x=bbo_aft_0.MarketParticipant,
    y=bbo_aft_0['QS'],
    labels={'x': 'Market', 'y':'Quoted Spread'})
fig.add_hline(
    y=nbbo_aft_0.iloc[0]['QS'],
    line_width=1, line_dash="dash", line_color="red",
    annotation_text="NBBO", annotation_font_color="red")
%plotly fig

Trazar QS para cada intervalo de tiempo y cada mercado para BBO

Utilice el siguiente código para trazar el diferencial cotizado para cada intervalo de tiempo y cada mercado para BBO:

fig = go.Figure(data=[
    go.Bar(name="before trade", x=bbo_bef.MarketParticipant.unique(), y=bbo_bef['QS']),
    go.Bar(name="0s after trade", x=bbo_aft_0.MarketParticipant.unique(), y=bbo_aft_0['QS']),
    go.Bar(name="1s after trade", x=bbo_aft_1.MarketParticipant.unique(), y=bbo_aft_1['QS']),
    go.Bar(name="10s after trade", x=bbo_aft_10.MarketParticipant.unique(), y=bbo_aft_10['QS']),
    go.Bar(name="60s after trade", x=bbo_aft_60.MarketParticipant.unique(), y=bbo_aft_60['QS'])])
fig.update_layout(barmode='group',title="BBO Quoted Spread Per Market/TimeFrame",
    xaxis={'title':'Market'},
    yaxis={'title':'Quoted Spread'})
%plotly fig

Trazar ES para cada intervalo de tiempo y mercado para BBO

Utilice el siguiente código para trazar el diferencial efectivo para cada intervalo de tiempo y mercado para BBO:

fig = go.Figure(data=[
    go.Bar(name="before trade", x=bbo_bef.MarketParticipant.unique(), y=bbo_bef['ES']),
    go.Bar(name="0s after trade", x=bbo_aft_0.MarketParticipant.unique(), y=bbo_aft_0['ES']),
    go.Bar(name="1s after trade", x=bbo_aft_1.MarketParticipant.unique(), y=bbo_aft_1['ES']),
    go.Bar(name="10s after trade", x=bbo_aft_10.MarketParticipant.unique(), y=bbo_aft_10['ES']),
    go.Bar(name="60s after trade", x=bbo_aft_60.MarketParticipant.unique(), y=bbo_aft_60['ES'])])
fig.update_layout(barmode='group',title="BBO Effective Spread Per Market/TimeFrame",
    xaxis={'title':'Market'}, 
    yaxis={'title':'Effective Spread'})
%plotly fig

Trazar el EQF para cada intervalo de tiempo y mercado para BBO

Utilice el siguiente código para trazar el diferencial efectivo/cotizado para cada intervalo de tiempo y mercado para BBO:

fig = go.Figure(data=[
    go.Bar(name="before trade", x=bbo_bef.MarketParticipant.unique(), y=bbo_bef['EQF']),
    go.Bar(name="0s after trade", x=bbo_aft_0.MarketParticipant.unique(), y=bbo_aft_0['EQF']),
    go.Bar(name="1s after trade", x=bbo_aft_1.MarketParticipant.unique(), y=bbo_aft_1['EQF']),
    go.Bar(name="10s after trade", x=bbo_aft_10.MarketParticipant.unique(), y=bbo_aft_10['EQF']),
    go.Bar(name="60s after trade", x=bbo_aft_60.MarketParticipant.unique(), y=bbo_aft_60['EQF'])])
fig.update_layout(barmode='group',title="BBO Effective/Quoted Spread Per Market/TimeFrame",
    xaxis={'title':'Market'}, 
    yaxis={'title':'Effective/Quoted Spread'})
%plotly fig

Rendimiento del cálculo de Athena Spark

Cuando ejecuta un bloque de código, Athena Spark determina automáticamente cuántas DPU requiere para completar el cálculo. En el último bloque de código, donde llamamos al tca_analysis función, en realidad le estamos indicando a Spark que procese los datos y luego convertimos los marcos de datos de Spark resultantes en marcos de datos de Pandas. Esta constituye la parte de procesamiento más intensiva del análisis, y cuando Athena Spark ejecuta este bloque, muestra la barra de progreso, el tiempo transcurrido y cuántas DPU están procesando datos actualmente. Por ejemplo, en el siguiente cálculo, Athena Spark utiliza 18 DPU.

Cuando configura su computadora portátil Athena Spark, tiene la opción de configurar la cantidad máxima de DPU que puede usar. El valor predeterminado es 20 DPU, pero probamos este cálculo con 10, 20 y 40 DPU para demostrar cómo Athena Spark escala automáticamente para ejecutar nuestro análisis. Observamos que Athena Spark escala linealmente, tomando 15 minutos y 21 segundos cuando la computadora portátil estaba configurada con un máximo de 10 DPU, 8 minutos y 23 segundos cuando la computadora portátil estaba configurada con 20 DPU, y 4 minutos y 44 segundos cuando la computadora portátil estaba configurada. configurado con 40 DPU. Debido a que Athena Spark cobra según el uso de DPU, con una granularidad por segundo, el costo de estos cálculos es similar, pero si establece un valor máximo de DPU más alto, Athena Spark puede devolver el resultado del análisis mucho más rápido. Para obtener más detalles sobre los precios de Athena Spark, haga clic esta página.

Conclusión

En esta publicación, demostramos cómo se pueden utilizar datos OPRA de alta fidelidad de Tick History-PCAP de LSEG para realizar análisis de costos de transacción utilizando Athena Spark. La disponibilidad de datos de OPRA de manera oportuna, complementada con innovaciones de accesibilidad de AWS Data Exchange para Amazon S3, reduce estratégicamente el tiempo de análisis para las empresas que buscan crear información procesable para decisiones comerciales críticas. OPRA genera alrededor de 7 TB de datos de Parquet normalizados cada día, y administrar la infraestructura para proporcionar análisis basados ​​en datos de OPRA es un desafío.

La escalabilidad de Athena en el manejo del procesamiento de datos a gran escala para Tick History – PCAP para datos OPRA la convierte en una opción convincente para las organizaciones que buscan soluciones de análisis rápidas y escalables en AWS. Esta publicación muestra la interacción perfecta entre el ecosistema de AWS y los datos de Tick History-PCAP y cómo las instituciones financieras pueden aprovechar esta sinergia para impulsar la toma de decisiones basada en datos para estrategias comerciales y de inversión críticas.

Acerca de los autores

Pramod Nayak es el Director de Gestión de Productos del Grupo de Baja Latencia en LSEG. Pramod tiene más de 10 años de experiencia en la industria de la tecnología financiera, centrándose en el desarrollo de software, análisis y gestión de datos. Pramod es un ex ingeniero de software y un apasionado de los datos de mercado y el comercio cuantitativo.

Lakshmi Kanth Mannem es Gerente de Producto en el Grupo de Baja Latencia de LSEG. Se centra en productos de plataforma y datos para la industria de datos de mercado de baja latencia. LakshmiKanth ayuda a los clientes a crear las soluciones más óptimas para sus necesidades de datos de mercado.

Vivek Aggarwal es ingeniero de datos senior en el grupo de baja latencia de LSEG. Vivek trabaja en el desarrollo y mantenimiento de canales de datos para el procesamiento y la entrega de fuentes de datos de mercado capturados y fuentes de datos de referencia.

Alket Memushaj es arquitecto principal en el equipo de desarrollo del mercado de servicios financieros de AWS. Alket es responsable de la estrategia técnica y trabaja con socios y clientes para implementar incluso las cargas de trabajo de los mercados de capitales más exigentes en la nube de AWS.

punto_img

Información más reciente

punto_img

Derechos de autor @ 2024 Plato Technologies Inc.