Bemästra marknadsdynamiken: Transformera transaktionskostnadsanalyser med ultraprecis Tick History – PCAP och Amazon Athena för Apache Spark | Amazon webbtjänster

Bemästra marknadsdynamiken: Transformera transaktionskostnadsanalyser med ultraprecis Tick History – PCAP och Amazon Athena för Apache Spark | Amazon webbtjänster

Tidsstämpel: 31 januari 2024 12:20
Källnod: 3091357

Det här inlägget är skrivet tillsammans med Pramod Nayak, LakshmiKanth Mannem och Vivek Aggarwal från Low Latency Group of LSEG.

Transaktionskostnadsanalys (TCA) används i stor utsträckning av handlare, portföljförvaltare och mäklare för analys före och efter handel, och hjälper dem att mäta och optimera transaktionskostnader och effektiviteten i deras handelsstrategier. I det här inlägget analyserar vi alternativ bud-fråga-spreadar från LSEG Tick History – PCAP dataset med hjälp av Amazon Athena för Apache Spark. Vi visar dig hur du kommer åt data, definierar anpassade funktioner att tillämpa på data, frågar och filtrerar datasetet och visualiserar resultaten av analysen, allt utan att behöva oroa dig för att sätta upp infrastruktur eller konfigurera Spark, även för stora datamängder.

Bakgrund

Options Price Reporting Authority (OPRA) fungerar som en viktig värdepappersinformationsprocessor, som samlar in, konsoliderar och sprider senaste försäljningsrapporter, offerter och relevant information för amerikanska optioner. Med 18 aktiva amerikanska optionsbörser och över 1.5 miljoner kvalificerade kontrakt spelar OPRA en avgörande roll för att tillhandahålla omfattande marknadsdata.

Den 5 februari 2024 kommer Securities Industry Automation Corporation (SIAC) att uppgradera OPRA-flödet från 48 till 96 multicast-kanaler. Denna förbättring syftar till att optimera symboldistribution och linjekapacitetsutnyttjande som svar på eskalerande handelsaktivitet och volatilitet på den amerikanska optionsmarknaden. SIAC har rekommenderat att företag förbereder sig för maximala datahastigheter på upp till 37.3 GBit per sekund.

Trots att uppgraderingen inte omedelbart ändrar den totala volymen publicerad data, gör den det möjligt för OPRA att sprida data i en betydligt snabbare takt. Denna övergång är avgörande för att möta kraven från den dynamiska optionsmarknaden.

OPRA framstår som en av de mest omfattande flödena, med en topp på 150.4 miljarder meddelanden på en enda dag under tredje kvartalet 3 och ett kapacitetsbehov på 2023 miljarder meddelanden under en dag. Att fånga upp varje enskilt meddelande är avgörande för analys av transaktionskostnader, marknadslikviditetsövervakning, utvärdering av handelsstrategi och marknadsundersökningar.

Om uppgifterna

LSEG Tick History – PCAP är ett molnbaserat arkiv som överstiger 30 PB och innehåller global marknadsdata av ultrahög kvalitet. Dessa data fångas noggrant direkt i utbytesdatacentren, med hjälp av redundanta fångstprocesser strategiskt placerade i stora primära datacenter och backup-datacenter över hela världen. LSEG:s fångstteknik säkerställer förlustfri datafångst och använder en GPS-tidskälla för nanosekunders tidsstämpelprecision. Dessutom används sofistikerade dataarbitragetekniker för att sömlöst fylla eventuella dataluckor. Efter fångst genomgår data noggrann bearbetning och skiljedom och normaliseras sedan till parkettformat med LSEG:s Real Time Ultra Direct (RTUD) foderhanterare.

Normaliseringsprocessen, som är integrerad för att förbereda data för analys, genererar upp till 6 TB komprimerade parkettfiler per dag. Den enorma mängden data tillskrivs OPRA:s omfattande karaktär, som sträcker sig över flera utbyten och innehåller många optionskontrakt som kännetecknas av olika attribut. Ökad marknadsvolatilitet och marknadsskapande aktivitet på optionsbörserna bidrar ytterligare till mängden data som publiceras på OPRA.

Attributen av Tick History – PCAP gör det möjligt för företag att utföra olika analyser, inklusive följande:

  • Analys före handel – Utvärdera potentiell handelspåverkan och utforska olika utförandestrategier baserat på historiska data
  • Utvärdering efter handel – Mät faktiska genomförandekostnader mot riktmärken för att bedöma genomförandet av strategier
  • optimerad utförande – Finjustera exekveringsstrategier baserade på historiska marknadsmönster för att minimera marknadspåverkan och minska de totala handelskostnaderna
  • Riskhantering – Identifiera glidmönster, identifiera extremvärden och proaktivt hantera risker förknippade med handelsaktiviteter
  • Prestandatillskrivning – Separera effekten av handelsbeslut från investeringsbeslut när portföljens prestanda analyseras

LSEG Tick History – PCAP-datauppsättningen är tillgänglig i AWS datautbyte och kan nås på AWS Marketplace. Med AWS Data Exchange för Amazon S3, kan du komma åt PCAP-data direkt från LSEG:s Amazon enkel lagringstjänst (Amazon S3) hinkar, vilket eliminerar behovet för företag att lagra sin egen kopia av data. Detta tillvägagångssätt effektiviserar datahantering och lagring, vilket ger kunderna omedelbar tillgång till högkvalitativ PCAP eller normaliserad data med enkel användning, integration och betydande datalagringsbesparingar.

Athena för Apache Spark

För analytiska ansträngningar, Athena för Apache Spark erbjuder en förenklad notebook-upplevelse tillgänglig via Athena-konsolen eller Athena API:er, så att du kan bygga interaktiva Apache Spark-applikationer. Med en optimerad Spark-körtid hjälper Athena analysen av petabyte data genom att dynamiskt skala antalet Spark-motorer på mindre än en sekund. Dessutom är vanliga Python-bibliotek som pandor och NumPy sömlöst integrerade, vilket möjliggör skapandet av invecklad applikationslogik. Flexibiliteten sträcker sig till import av anpassade bibliotek för användning i bärbara datorer. Athena for Spark rymmer de flesta öppna dataformat och är sömlöst integrerat med AWS-lim Datakatalog.

dataset

För denna analys använde vi datauppsättningen LSEG Tick History – PCAP OPRA från 17 maj 2023. Denna datauppsättning består av följande komponenter:

  • Bästa bud och erbjudande (BBO) – Rapporterar det högsta budet och det lägsta budet för ett värdepapper vid en given börs
  • Nationellt bästa bud och erbjudande (NBBO) – Rapporterar det högsta budet och det lägsta budet för en säkerhet på alla börser
  • Handel – Registrerar genomförda affärer på alla börser

Datauppsättningen omfattar följande datavolymer:

  • Handel – 160 MB fördelat på cirka 60 komprimerade parkettfiler
  • BBO – 2.4 TB fördelat på cirka 300 komprimerade parkettfiler
  • NBBO – 2.8 TB fördelat på cirka 200 komprimerade parkettfiler

Analysöversikt

Att analysera OPRA Tick History-data för Transaction Cost Analysis (TCA) innebär att granska marknadsnoteringar och affärer kring en specifik handelshändelse. Vi använder följande mätvärden som en del av denna studie:

  • Citerad spridning (QS) – Beräknas som skillnaden mellan BBO-budet och BBO-budet
  • Effektiv spridning (ES) – Beräknas som skillnaden mellan handelspriset och mittpunkten för BBO (BBO bud + (BBO ask – BBO bud)/2)
  • Effektiv/noterad spread (EQF) – Beräknat som (ES / QS) * 100

Vi beräknar dessa spreadar före handeln och dessutom med fyra intervaller efter handeln (strax efter, 1 sekund, 10 sekunder och 60 sekunder efter handeln).

Konfigurera Athena för Apache Spark

För att konfigurera Athena för Apache Spark, utför följande steg:

  1. På Athena-konsolen, under KOM IGÅNG, Välj Analysera dina data med PySpark och Spark SQL.
  2. Om det här är första gången du använder Athena Spark, välj Skapa arbetsgrupp.
  3. För Arbetsgruppens namn¸ ange ett namn för arbetsgruppen, t.ex tca-analysis.
  4. I Analytics-motor avsnitt, välj Apache Spark.
  5. I Ytterligare konfigurationer avsnitt kan du välja Använd standardinställningar eller tillhandahålla en anpassad AWS identitets- och åtkomsthantering (IAM) roll och Amazon S3-plats för beräkningsresultat.
  6. Välja Skapa arbetsgrupp.
  7. När du har skapat arbetsgruppen, navigera till bärbara datorer fliken och välj Skapa anteckningsbok.
  8. Ange ett namn för din anteckningsbok, t.ex tca-analysis-with-tick-history.
  9. Välja Skapa för att skapa din anteckningsbok.

Starta din anteckningsbok

Om du redan har skapat en Spark-arbetsgrupp väljer du Starta anteckningsbokredigeraren under KOM IGÅNG.


När din anteckningsbok har skapats omdirigeras du till den interaktiva anteckningsbokredigeraren.


Nu kan vi lägga till och köra följande kod till vår anteckningsbok.

Skapa en analys

Utför följande steg för att skapa en analys:

  • Importera vanliga bibliotek:
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go

  • Skapa våra dataramar för BBO, NBBO och affärer:
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")

  • Nu kan vi identifiera en handel att använda för transaktionskostnadsanalys:
filtered_trades = spark.sql("select Product, Price,Quantity, ReceiptTimestamp, MarketParticipant from trades")

Vi får följande utdata:

+---------------------+---------------------+---------------------+-------------------+-----------------+ 
|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|
+---------------------+---------------------+---------------------+-------------------+-----------------+

Vi använder den markerade handelsinformationen framöver för handelsprodukten (tp), handelspris (tpr) och handelstid (tt).

  • Här skapar vi ett antal hjälpfunktioner för vår analys
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

  • I följande funktion skapar vi datasetet som innehåller alla citat före och efter handeln. Athena Spark bestämmer automatiskt hur många DPU:er som ska startas för bearbetning av vår datauppsättning.
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

  • Låt oss nu kalla TCA-analysfunktionen med informationen från vår utvalda handel:
tp = "QQQ 230518C00329000"
tpr = 1.16
tt = 1684338579104713924
c = get_tca_analysis_via_df_single_query(tp, tpr, tt)

Visualisera analysresultaten

Låt oss nu skapa dataramarna vi använder för vår visualisering. Varje dataram innehåller citat för ett av de fem tidsintervallen för varje dataflöde (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)]

I följande avsnitt tillhandahåller vi exempelkod för att skapa olika visualiseringar.

Rita QS och NBBO före handeln

Använd följande kod för att plotta den noterade spreaden och NBBO före handeln:

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

Rita QS för varje marknad och NBBO efter handeln

Använd följande kod för att plotta den noterade spreaden för varje marknad och NBBO omedelbart efter handeln:

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

Rita QS för varje tidsintervall och varje marknad för BBO

Använd följande kod för att plotta den noterade spreaden för varje tidsintervall och varje marknad för 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

Rita ES för varje tidsintervall och marknad för BBO

Använd följande kod för att plotta den effektiva spridningen för varje tidsintervall och marknad för 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

Rita EQF för varje tidsintervall och marknad för BBO

Använd följande kod för att plotta den effektiva/noterade spridningen för varje tidsintervall och marknad för 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

Athena Spark beräkningsprestanda

När du kör ett kodblock bestämmer Athena Spark automatiskt hur många DPU:er som krävs för att slutföra beräkningen. I det sista kodblocket, där vi kallar tca_analysis funktion, instruerar vi faktiskt Spark att bearbeta data, och vi konverterar sedan de resulterande Spark-dataramarna till Pandas-dataramar. Detta utgör den mest intensiva bearbetningsdelen av analysen, och när Athena Spark kör detta block visar det förloppsindikatorn, förfluten tid och hur många DPU:er som bearbetar data för närvarande. Till exempel, i följande beräkning, använder Athena Spark 18 DPU:er.

När du konfigurerar din Athena Spark-anteckningsbok har du möjlighet att ställa in det maximala antalet DPU:er som den kan använda. Standard är 20 DPU:er, men vi testade den här beräkningen med 10, 20 och 40 DPU:er för att visa hur Athena Spark automatiskt skalas för att köra vår analys. Vi observerade att Athena Spark skalas linjärt och tog 15 minuter och 21 sekunder när den bärbara datorn konfigurerades med maximalt 10 DPU:er, 8 minuter och 23 sekunder när den bärbara datorn konfigurerades med 20 DPU:er och 4 minuter och 44 sekunder när den bärbara datorn var konfigurerad med 40 DPU:er. Eftersom Athena Spark tar betalt baserat på DPU-användning, med en granularitet per sekund, är kostnaden för dessa beräkningar liknande, men om du ställer in ett högre maximalt DPU-värde kan Athena Spark returnera resultatet av analysen mycket snabbare. För mer information om priserna på Athena Spark klicka här..

Slutsats

I det här inlägget demonstrerade vi hur du kan använda high-fidelity OPRA-data från LSEG:s Tick History-PCAP för att utföra transaktionskostnadsanalyser med Athena Spark. Tillgången till OPRA-data i rätt tid, kompletterad med tillgänglighetsinnovationer från AWS Data Exchange för Amazon S3, minskar strategiskt tiden till analys för företag som vill skapa handlingskraftiga insikter för viktiga handelsbeslut. OPRA genererar cirka 7 TB normaliserade parkettdata varje dag, och det är en utmaning att hantera infrastrukturen för att tillhandahålla analyser baserade på OPRA-data.

Athenas skalbarhet vid hantering av storskalig databehandling för Tick History – PCAP för OPRA-data gör det till ett övertygande val för organisationer som söker snabba och skalbara analyslösningar i AWS. Det här inlägget visar den sömlösa interaktionen mellan AWS-ekosystemet och Tick History-PCAP-data och hur finansinstitutioner kan dra fördel av denna synergi för att driva datadrivet beslutsfattande för kritiska handels- och investeringsstrategier.

Om författarna

Pramod Nayak är direktör för produkthantering för Low Latency Group på LSEG. Pramod har över 10 års erfarenhet inom finansteknikbranschen, med fokus på mjukvaruutveckling, analys och datahantering. Pramod är en före detta mjukvaruingenjör och brinner för marknadsdata och kvantitativ handel.

LakshmiKanth Mannem är produktchef i LSEG-gruppen för låg latens. Han fokuserar på data- och plattformsprodukter för marknadsdataindustrin med låg latens. LakshmiKanth hjälper kunder att bygga de mest optimala lösningarna för deras marknadsdatabehov.

Vivek Aggarwal är Senior Data Engineer i Low Latency Group av LSEG. Vivek arbetar med att utveckla och underhålla datapipelines för bearbetning och leverans av infångade marknadsdataflöden och referensdataflöden.

Alket Memushaj är huvudarkitekt i Financial Services Market Development-teamet på AWS. Alket ansvarar för teknisk strategi och arbetar med partners och kunder för att distribuera även de mest krävande arbetsbelastningarna på kapitalmarknaden till AWS-molnet.

Tidsstämpel:

Mer från AWS Big Data