Stăpânirea dinamicii pieței: Transformarea analizei costurilor de tranzacție cu Tick History ultra-precise – PCAP și Amazon Athena pentru Apache Spark | Amazon Web Services

Stăpânirea dinamicii pieței: Transformarea analizei costurilor de tranzacție cu Tick History ultra-precise – PCAP și Amazon Athena pentru Apache Spark | Amazon Web Services

Marca temporală: 31 ianuarie 2024 12:20
Nodul sursă: 3091357

Această postare este scrisă împreună cu Pramod Nayak, LakshmiKanth Mannem și Vivek Aggarwal de la Low Latency Group al LSEG.

Analiza costurilor de tranzacție (TCA) este utilizată pe scară largă de către comercianți, administratorii de portofoliu și brokerii pentru analize pre-tranzacționare și post-tranzacționare și îi ajută să măsoare și să optimizeze costurile tranzacției și eficacitatea strategiilor lor de tranzacționare. În această postare, analizăm diferențele dintre opțiunile licitare și cerere din Istoricul căpuțelor LSEG – PCAP setul de date folosind Amazon Athena pentru Apache Spark. Vă arătăm cum să accesați date, să definiți funcții personalizate de aplicat asupra datelor, să interogați și să filtrați setul de date și să vizualizați rezultatele analizei, totul fără a vă face griji cu privire la configurarea infrastructurii sau configurarea Spark, chiar și pentru seturi de date mari.

Context

Options Price Reporting Authority (OPRA) servește ca un procesator de informații esențial privind valorile mobiliare, colectând, consolidând și difuzând rapoarte de ultima vânzare, cotații și informații relevante pentru Opțiunile din SUA. Cu 18 burse active de opțiuni din SUA și peste 1.5 milioane de contracte eligibile, OPRA joacă un rol esențial în furnizarea de date complete de piață.

Pe 5 februarie 2024, Securities Industry Automation Corporation (SIAC) este setat să actualizeze fluxul OPRA de la 48 la 96 de canale multicast. Această îmbunătățire urmărește să optimizeze distribuția simbolurilor și utilizarea capacității liniei ca răspuns la creșterea activității de tranzacționare și a volatilității pe piața de opțiuni din SUA. SIAC a recomandat firmelor să se pregătească pentru rate de date de vârf de până la 37.3 GBiți pe secundă.

În ciuda faptului că actualizarea nu modifică imediat volumul total de date publicate, aceasta permite OPRA să disemineze datele într-un ritm semnificativ mai rapid. Această tranziție este crucială pentru a răspunde cerințelor pieței de opțiuni dinamice.

OPRA se remarcă drept unul dintre cele mai voluminoase fluxuri, cu un vârf de 150.4 miliarde de mesaje într-o singură zi în T3 2023 și o cerință de capacitate de 400 de miliarde de mesaje într-o singură zi. Captarea fiecărui mesaj este esențială pentru analiza costurilor de tranzacție, monitorizarea lichidității pieței, evaluarea strategiei de tranzacționare și cercetarea pieței.

Despre date

Istoricul căpuțelor LSEG – PCAP este un depozit bazat pe cloud, care depășește 30 PB, care adăpostește date de piață globală de foarte înaltă calitate. Aceste date sunt capturate cu meticulozitate direct în centrele de schimb de date, utilizând procese de captare redundante poziționate strategic în centrele de schimb de date principale și de rezervă din întreaga lume. Tehnologia de captare a LSEG asigură captarea datelor fără pierderi și folosește o sursă de timp GPS pentru precizia marcajului de timp în nanosecunde. În plus, sunt folosite tehnici sofisticate de arbitrare a datelor pentru a umple fără probleme orice goluri de date. După capturare, datele sunt supuse procesării și arbitrajului meticulos și apoi sunt normalizate în formatul Parquet folosind Ultra Direct în timp real al LSEG (RTUD) manipulatoare de furaje.

Procesul de normalizare, care este parte integrantă a pregătirii datelor pentru analiză, generează până la 6 TB de fișiere Parquet comprimate pe zi. Volumul masiv de date este atribuit naturii cuprinzătoare a OPRA, care acoperă mai multe schimburi și prezentând numeroase contracte de opțiuni caracterizate de atribute diverse. Volatilitatea crescută a pieței și activitatea de creare a pieței pe bursele de opțiuni contribuie și mai mult la volumul de date publicate pe OPRA.

Atributele Tick History – PCAP permit firmelor să efectueze diverse analize, inclusiv următoarele:

  • Analiză înainte de tranzacționare – Evaluați impactul potențial al comerțului și explorați diferite strategii de execuție bazate pe date istorice
  • Evaluare post-tranzacționare – Măsurați costurile reale de execuție în raport cu valorile de referință pentru a evalua performanța strategiilor de execuție
  • Optimizat execuție – Ajustați strategiile de execuție pe baza modelelor istorice ale pieței pentru a minimiza impactul pe piață și a reduce costurile globale de tranzacționare
  • de gestionare a riscurilor – Identificați modelele de alunecare, identificați valorile aberante și gestionați în mod proactiv riscurile asociate activităților de tranzacționare
  • Atribuirea performanței – Separați impactul deciziilor de tranzacționare de deciziile de investiții atunci când analizați performanța portofoliului

Setul de date LSG Tick History – PCAP este disponibil în Schimb de date AWS și poate fi accesat pe Piața AWS. Cu AWS Data Exchange pentru Amazon S3, puteți accesa datele PCAP direct de la LSEG Serviciul Amazon de stocare simplă (Amazon S3), eliminând nevoia firmelor de a stoca propria copie a datelor. Această abordare simplifică gestionarea și stocarea datelor, oferind clienților acces imediat la PCAP de înaltă calitate sau la date normalizate cu ușurință în utilizare, integrare și economii substanțiale de stocare a datelor.

Athena pentru Apache Spark

Pentru eforturi analitice, Athena pentru Apache Spark oferă o experiență simplificată de notebook accesibilă prin consola Athena sau API-urile Athena, permițându-vă să construiți aplicații interactive Apache Spark. Cu un timp de rulare Spark optimizat, Athena ajută la analiza petaocteților de date prin scalarea dinamică a numărului de motoare Spark la mai puțin de o secundă. Mai mult, bibliotecile Python obișnuite, cum ar fi Pandas și NumPy, sunt integrate perfect, permițând crearea unei logici complexe a aplicației. Flexibilitatea se extinde la importul de biblioteci personalizate pentru utilizare în notebook-uri. Athena pentru Spark găzduiește majoritatea formatelor de date deschise și este integrat perfect cu AWS Adeziv Catalog de date.

Setul de date

Pentru această analiză, am folosit setul de date LSEG Tick History – PCAP OPRA din 17 mai 2023. Acest set de date cuprinde următoarele componente:

  • Cea mai bună ofertă și ofertă (BBO) – Raportează cea mai mare ofertă și cea mai mică cerere pentru un titlu la o anumită bursă
  • Cea mai bună ofertă și ofertă națională (NBBO) – Raportează cea mai mare ofertă și cea mai mică cerere pentru o valoare pe toate schimburile
  • Tranzacții – Înregistrează tranzacțiile finalizate pe toate bursele

Setul de date implică următoarele volume de date:

  • Tranzacții – 160 MB distribuiti în aproximativ 60 de fișiere Parquet comprimate
  • BBO – 2.4 TB distribuite în aproximativ 300 de fișiere Parquet comprimate
  • NBBO – 2.8 TB distribuite în aproximativ 200 de fișiere Parquet comprimate

Prezentare generală a analizei

Analiza datelor OPRA Tick History pentru Analiza costurilor de tranzacție (TCA) implică examinarea cotațiilor și tranzacțiilor de pe piață în jurul unui anumit eveniment comercial. Utilizăm următoarele valori ca parte a acestui studiu:

  • spread cotat (QS) – Calculat ca diferență între cererea BBO și oferta BBO
  • Răspândire efectivă (ES) – Calculat ca diferență dintre prețul de tranzacționare și punctul de mijloc al BBO (BBO bid + (BBO ask – BBO bid)/2)
  • Marja efectivă/cotată (EQF) – Calculat ca (ES / QS) * 100

Calculăm aceste spread-uri înainte de tranzacționare și, suplimentar, la patru intervale după tranzacție (imediat după, 1 secundă, 10 secunde și 60 de secunde după tranzacție).

Configurați Athena pentru Apache Spark

Pentru a configura Athena pentru Apache Spark, parcurgeți următorii pași:

  1. Pe consola Athena, sub Incepe, Selectați Analizați-vă datele folosind PySpark și Spark SQL.
  2. Dacă este prima dată când utilizați Athena Spark, alegeți Creați un grup de lucru.
  3. Pentru Numele grupului de lucru¸ introduceți un nume pentru grupul de lucru, cum ar fi tca-analysis.
  4. În Motor de analiză secțiune, selectați Apache Spark.
  5. În Configurații suplimentare secțiunea, puteți alege Utilizați valorile implicite sau furnizați un obicei Gestionarea identității și accesului AWS (IAM) și locația Amazon S3 pentru rezultatele calculului.
  6. Alege Creați un grup de lucru.
  7. După ce creați grupul de lucru, navigați la notebook-uri filă și alegeți Creați un caiet.
  8. Introduceți un nume pentru blocnotes, cum ar fi tca-analysis-with-tick-history.
  9. Alege Crea pentru a-ți crea caietul.

Lansați blocnotesul

Dacă ați creat deja un grup de lucru Spark, selectați Lansați editorul de notebook în Incepe.


După ce ați creat blocnotesul, veți fi redirecționat către editorul interactiv de blocnotes.


Acum putem adăuga și rula următorul cod pe notebook-ul nostru.

Creați o analiză

Parcurgeți următorii pași pentru a crea o analiză:

  • Importă biblioteci comune:
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go

  • Creați cadrele noastre de date pentru BBO, NBBO și tranzacții:
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")

  • Acum putem identifica o tranzacție de utilizat pentru analiza costurilor de tranzacție:
filtered_trades = spark.sql("select Product, Price,Quantity, ReceiptTimestamp, MarketParticipant from trades")

Obținem următoarea ieșire:

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

Folosim informațiile comerciale evidențiate în viitor pentru produsul comercial (tp), prețul comercial (tpr) și timpul de tranzacționare (tt).

  • Aici creăm o serie de funcții de ajutor pentru analiza noastră
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

  • În următoarea funcție, creăm setul de date care conține toate cotațiile înainte și după tranzacție. Athena Spark determină automat câte DPU-uri să lanseze pentru procesarea setului nostru de date.
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

  • Acum să apelăm funcția de analiză TCA cu informațiile din comerțul nostru selectat:
tp = "QQQ 230518C00329000"
tpr = 1.16
tt = 1684338579104713924
c = get_tca_analysis_via_df_single_query(tp, tpr, tt)

Vizualizați rezultatele analizei

Acum să creăm cadrele de date pe care le folosim pentru vizualizarea noastră. Fiecare cadru de date conține citate pentru unul dintre cele cinci intervale de timp pentru fiecare flux de date (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)]

În secțiunile următoare, oferim exemplu de cod pentru a crea diferite vizualizări.

Plot QS și NBBO înainte de tranzacționare

Utilizați următorul cod pentru a reprezenta un grafic spread-ul cotat și NBBO înainte de tranzacționare:

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

Trasează QS pentru fiecare piață și NBBO după tranzacție

Utilizați următorul cod pentru a reprezenta un grafic spread-ul cotat pentru fiecare piață și NBBO imediat după tranzacție:

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

Trasează QS pentru fiecare interval de timp și pentru fiecare piață pentru BBO

Utilizați următorul cod pentru a reprezenta un grafic spread-ul cotat pentru fiecare interval de timp și fiecare piață pentru 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

Graficul ES pentru fiecare interval de timp și piață pentru BBO

Utilizați următorul cod pentru a reprezenta un grafic spread-ul efectiv pentru fiecare interval de timp și piață pentru 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

Trasează EQF pentru fiecare interval de timp și piață pentru BBO

Utilizați următorul cod pentru a reprezenta un grafic spread-ul efectiv/cotat pentru fiecare interval de timp și piață pentru 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

Performanța calculului Athena Spark

Când rulați un bloc de cod, Athena Spark determină automat de câte DPU-uri necesită pentru a finaliza calculul. În ultimul bloc de cod, unde numim tca_analysis de fapt, instruim Spark să proceseze datele și apoi convertim cadrele de date Spark rezultate în cadre de date Pandas. Aceasta constituie cea mai intensă parte de procesare a analizei, iar când Athena Spark rulează acest bloc, arată bara de progres, timpul scurs și câte DPU-uri procesează date în prezent. De exemplu, în calculul următor, Athena Spark utilizează 18 DPU-uri.

Când vă configurați notebook-ul Athena Spark, aveți opțiunea de a seta numărul maxim de DPU-uri pe care le poate folosi. Valoarea implicită este de 20 de DPU, dar am testat acest calcul cu 10, 20 și 40 de DPU pentru a demonstra modul în care Athena Spark se scalează automat pentru a rula analiza noastră. Am observat că Athena Spark scalează liniar, luând 15 minute și 21 de secunde când notebook-ul a fost configurat cu maximum 10 DPU, 8 minute și 23 de secunde când notebook-ul a fost configurat cu 20 DPU și 4 minute și 44 de secunde când notebook-ul a fost configurat. configurat cu 40 DPU-uri. Deoarece Athena Spark taxează pe baza utilizării DPU, la o granularitate pe secundă, costul acestor calcule este similar, dar dacă setați o valoare maximă DPU mai mare, Athena Spark poate returna rezultatul analizei mult mai rapid. Pentru mai multe detalii despre prețurile Athena Spark, vă rugăm să faceți clic aici.

Concluzie

În această postare, am demonstrat cum puteți utiliza datele OPRA de înaltă fidelitate din Tick History-PCAP de la LSEG pentru a efectua analize ale costurilor de tranzacție folosind Athena Spark. Disponibilitatea în timp util a datelor OPRA, completată cu inovațiile de accesibilitate ale AWS Data Exchange pentru Amazon S3, reduce strategic timpul de analiză pentru firmele care doresc să creeze informații utile pentru deciziile de tranzacționare critice. OPRA generează aproximativ 7 TB de date Parquet normalizate în fiecare zi, iar gestionarea infrastructurii pentru a oferi analize bazate pe datele OPRA este o provocare.

Scalabilitatea Athena în gestionarea procesării datelor la scară largă pentru Tick History – PCAP pentru datele OPRA îl face o alegere convingătoare pentru organizațiile care caută soluții de analiză rapide și scalabile în AWS. Această postare arată interacțiunea perfectă dintre ecosistemul AWS și datele Tick History-PCAP și modul în care instituțiile financiare pot profita de această sinergie pentru a stimula luarea deciziilor bazate pe date pentru strategii critice de tranzacționare și investiții.

Despre Autori

Pramod Nayak este director de management de produs al grupului de latență scăzută la LSEG. Pramod are peste 10 ani de experiență în industria tehnologiei financiare, concentrându-se pe dezvoltarea de software, analiză și managementul datelor. Pramod este un fost inginer de software și pasionat de datele de piață și de tranzacționarea cantitativă.

LakshmiKanth Mannem este manager de produs în grupul Low Latency al LSEG. El se concentrează pe produse de date și platforme pentru industria datelor de piață cu latență scăzută. LakshmiKanth îi ajută pe clienți să construiască cele mai optime soluții pentru nevoile lor de date pe piață.

Vivek Aggarwal este inginer senior de date în grupul Low Latency al LSEG. Vivek lucrează la dezvoltarea și menținerea conductelor de date pentru procesarea și livrarea fluxurilor de date de piață capturate și a fluxurilor de date de referință.

Alket Memushaj este arhitect principal în echipa de dezvoltare a pieței de servicii financiare de la AWS. Alket este responsabil pentru strategia tehnică, lucrând cu parteneri și clienți pentru a implementa chiar și cele mai solicitante sarcini de lucru pe piețele de capital în AWS Cloud.

Timestamp-ul:

Mai mult de la AWS Big Data