Turudünaamika valdamine: tehingukulude analüütika muutmine ülitäpse puugiajaloo abil – PCAP ja Amazon Athena Apache Sparkile | Amazoni veebiteenused

Turudünaamika valdamine: tehingukulude analüütika muutmine ülitäpse puugiajaloo abil – PCAP ja Amazon Athena Apache Sparkile | Amazoni veebiteenused

Ajatempel: 31. jaanuar 2024 12:20
Allikasõlm: 3091357

Selle postituse on kirjutanud Pramod Nayak, LakshmiKanth Mannem ja Vivek Aggarwal LSEG madala latentsusajaga rühmast.

Tehingukulude analüüsi (TCA) kasutavad kauplejad, portfellihaldurid ja maaklerid laialdaselt tehingueelseks ja -järgseks analüüsiks ning see aitab neil tehingukulusid ja kauplemisstrateegiate tõhusust mõõta ja optimeerida. Selles postituses analüüsime valikuid pakkumise-küsimise vahesid LSEG puugi ajalugu – PCAP andmekogum kasutades Amazon Athena Apache Sparkile. Näitame teile, kuidas andmetele juurde pääseda, andmetele rakendatavaid kohandatud funktsioone määratleda, andmestikku päringuid teha ja filtreerida ning analüüsi tulemusi visualiseerida, ilma et peaksite muretsema infrastruktuuri seadistamise või Sparki konfigureerimise pärast isegi suurte andmekogumite puhul.

Taust

Optsioonide hinnaaruandlusamet (OPRA) toimib olulise väärtpaberiteabe töötlejana, kogudes, koondades ja levitades USA optsioonide viimase müügi aruandeid, hinnapakkumisi ja asjakohast teavet. 18 aktiivse USA optsioonibörsi ja üle 1.5 miljoni kõlbliku lepinguga mängib OPRA keskset rolli kõikehõlmavate turuandmete pakkumisel.

5. veebruaril 2024 kavatseb väärtpaberitööstuse automatiseerimise korporatsioon (SIAC) uuendada OPRA kanalit 48-lt 96-le multiedastuskanalile. Selle täiuse eesmärk on optimeerida sümbolite levitamist ja liinide võimsuse kasutamist vastuseks kasvavale kauplemisaktiivsusele ja volatiilsusele USA optsiooniturul. SIAC on soovitanud ettevõtetel valmistuda maksimaalseks andmeedastuskiiruseks kuni 37.3 GB/s.

Vaatamata sellele, et uuendus ei muuda kohe avaldatud andmete kogumahtu, võimaldab see OPRA-l andmeid levitada oluliselt kiiremini. See üleminek on dünaamilise optsioonituru nõudmiste rahuldamiseks ülioluline.

OPRA paistab silma kui üks mahukamaid vooge, 150.4. aasta kolmandas kvartalis on 3 miljardit sõnumit ühes päevas ja ühe päeva jooksul on vaja 2023 miljardit sõnumit. Iga sõnumi jäädvustamine on tehingukulude analüüsi, turu likviidsuse jälgimise, kauplemisstrateegia hindamise ja turu-uuringute jaoks ülioluline.

Andmete kohta

LSEG puugi ajalugu – PCAP on pilvepõhine hoidla, mille maht on üle 30 PB ja mis sisaldab ülikvaliteetseid globaalse turu andmeid. Need andmed kogutakse hoolikalt otse vahetusandmekeskustes, kasutades üleliigseid kogumisprotsesse, mis on strateegiliselt paigutatud peamistes esmastes ja varuandmevahetuskeskustes kogu maailmas. LSEG-i püüdmistehnoloogia tagab kadudeta andmete kogumise ja kasutab nanosekundilise ajatempli täpsuse jaoks GPS-i ajaallikat. Lisaks kasutatakse andmelünkade sujuvaks täitmiseks keerukaid andmearbitraaži tehnikaid. Pärast kogumist töödeldakse andmeid põhjalikult ja arutatakse ning seejärel normaliseeritakse need Parketi vormingusse, kasutades LSEG reaalajas Ultra Direct (RTUD) söödakäitlejad.

Normaliseerimisprotsess, mis on andmete analüüsiks ettevalmistamise lahutamatu osa, genereerib kuni 6 TB tihendatud Parketi faile päevas. Suur andmemaht on tingitud OPRA kõikehõlmavast olemusest, mis hõlmab mitut vahetust ja sisaldab arvukalt optsioonilepinguid, mida iseloomustavad erinevad atribuudid. Turu suurenenud volatiilsus ja turutegemise aktiivsus optsioonibörsidel suurendavad veelgi OPRA avaldatud andmete mahtu.

Tick ​​History – PCAP atribuudid võimaldavad ettevõtetel teha erinevaid analüüse, sealhulgas järgmist:

  • Kauplemiseelne analüüs – Hinnake potentsiaalset kaubandusmõju ja uurige ajalooandmete põhjal erinevaid täitmisstrateegiaid
  • Kauplemisjärgne hindamine – Mõõtke tegelikke täitmiskulusid võrdlusnäitajatega, et hinnata täitmisstrateegiate toimivust
  • Optimaalne täitmine - Viimistlege täitmisstrateegiaid, mis põhinevad ajaloolistel turumudelitel, et minimeerida turumõju ja vähendada üldisi kauplemiskulusid
  • Riskijuhtimine – Tehke kindlaks libisemismustrid, tuvastage kõrvalekalded ja juhtige ennetavalt kauplemistegevusega seotud riske
  • Toimivuse omistamine – Portfelli tootluse analüüsimisel eraldage kauplemisotsuste mõju investeerimisotsustest

LSEG Tick History – PCAP andmestik on saadaval AWS-i andmevahetus ja sellele pääseb juurde aadressil AWS Marketplace. Koos AWS-i andmevahetus Amazon S3 jaoks, pääsete PCAP-andmetele juurde otse LSEG-idest Amazoni lihtne salvestusteenus (Amazon S3) ämbrid, mis välistavad ettevõtete vajaduse salvestada oma andmete koopiad. See lähenemisviis lihtsustab andmete haldamist ja salvestamist, pakkudes klientidele kohest juurdepääsu kvaliteetsetele PCAP-i või normaliseeritud andmetele, mida on lihtne kasutada, integreerida ja märkimisväärne kokkuhoid andmete salvestamisel.

Athena Apache Sparkile

Analüütiliste püüdluste jaoks Athena Apache Sparkile pakub lihtsustatud sülearvuti kasutuskogemust, millele pääseb juurde Athena konsooli või Athena API-de kaudu, võimaldades teil luua interaktiivseid Apache Sparki rakendusi. Optimeeritud Sparki käitusajaga aitab Athena petabaitide arvu andmeid analüüsida, skaleerides dünaamiliselt Sparki mootorite arvu, mis jääb alla sekundi. Lisaks on tavalised Pythoni teegid, nagu pandad ja NumPy, sujuvalt integreeritud, võimaldades luua keerukat rakendusloogikat. Paindlikkus laieneb kohandatud teekide importimisele sülearvutites kasutamiseks. Athena for Spark mahutab enamiku avatud andmevormingutega ja on sujuvalt integreeritud AWS liim Andmekataloog.

Andmebaas

Selle analüüsi jaoks kasutasime LSEG Tick History – PCAP OPRA andmekogumit alates 17. maist 2023. See andmestik sisaldab järgmisi komponente.

  • Parim pakkumine (BBO) – Teatab antud börsil väärtpaberi kõrgeima pakkumise ja madalaima pakkumise kohta
  • Riigi parim pakkumine (NBBO) – Teatab kõigi börside kõrgeima pakkumise ja madalaima tagatise küsimise kohta
  • Trades - Salvestab kõigi börside lõpetatud tehinguid

Andmekogum hõlmab järgmisi andmemahtusid:

  • Trades – 160 MB, mis on jaotatud ligikaudu 60 tihendatud Parketi faili vahel
  • BBO – 2.4 TB, mis on jaotatud ligikaudu 300 tihendatud Parketi faili vahel
  • NBBO – 2.8 TB, mis on jaotatud ligikaudu 200 tihendatud Parketi faili vahel

Analüüsi ülevaade

OPRA Tick History andmete analüüsimine tehingukulude analüüsi (TCA) jaoks hõlmab turu noteeringute ja tehingute kontrollimist konkreetse kaubandussündmuse ümber. Selle uuringu osana kasutame järgmisi mõõdikuid.

  • Tsiteeritud hinnavahe (QS) – Arvutatakse BBO müügi ja BBO pakkumise vahena
  • Efektiivne levik (ES) – Arvutatakse tehinguhinna ja BBO keskpunkti vahena (BBO pakkumine + (BBO pakkumine – BBO pakkumine)/2)
  • Efektiivne/tsiteeritud vahe (EQF) – Arvutatud kui (ES / QS) * 100

Arvutame need hinnavahed enne tehingut ja lisaks nelja intervalliga pärast tehingut (vahetult pärast, 1 sekund, 10 sekundit ja 60 sekundit pärast tehingut).

Seadistage Athena Apache Sparki jaoks

Athena konfigureerimiseks Apache Sparki jaoks toimige järgmiselt.

  1. Athena konsoolil, all Alustaminevalige Analüüsige oma andmeid PySparki ja Spark SQL-i abil.
  2. Kui kasutate Athena Sparki esimest korda, valige Loo töörühm.
  3. eest Töörühma nimi¸ sisestage töörühma nimi, näiteks tca-analysis.
  4. aasta Analüütika mootor jaotises valige Apache Spark.
  5. aasta Täiendavad konfiguratsioonid jaotises saate valida Kasutage vaikeseadeid või pakkuda kohandatud AWS-i identiteedi- ja juurdepääsuhaldus (IAM) roll ja Amazon S3 asukoht arvutustulemuste jaoks.
  6. Vali Loo töörühm.
  7. Pärast töörühma loomist liikuge lehele Sülearvutid ja valige Loo märkmik.
  8. Sisestage oma märkmikule nimi, näiteks tca-analysis-with-tick-history.
  9. Vali Looma märkmiku loomiseks.

Käivitage oma märkmik

Kui olete Sparki töörühma juba loonud, valige Käivitage märkmiku redaktor all Alustamine.


Pärast märkmiku loomist suunatakse teid interaktiivsesse märkmikuredaktorisse.


Nüüd saame oma märkmikusse lisada ja käivitada järgmise koodi.

Looge analüüs

Analüüsi loomiseks tehke järgmised sammud.

  • Impordi levinud teegid:
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go

  • Looge meie andmeraamid BBO, NBBO ja tehingute jaoks:
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")

  • Nüüd saame tuvastada tehingu, mida tehingukulude analüüsiks kasutada:
filtered_trades = spark.sql("select Product, Price,Quantity, ReceiptTimestamp, MarketParticipant from trades")

Saame järgmise väljundi:

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

Edaspidi kasutame esiletõstetud kaubandusteavet kaubandusliku toote (tp), kauplemishinna (tpr) ja kauplemisaja (tt) jaoks.

  • Siin loome oma analüüsi jaoks mitmeid abifunktsioone
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

  • Järgmises funktsioonis loome andmestiku, mis sisaldab kõiki noteeringuid enne ja pärast tehingut. Athena Spark määrab automaatselt, mitu DPU-d meie andmestiku töötlemiseks käivitada.
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

  • Nüüd kutsume TCA analüüsi funktsiooni meie valitud kaubanduse teabega:
tp = "QQQ 230518C00329000"
tpr = 1.16
tt = 1684338579104713924
c = get_tca_analysis_via_df_single_query(tp, tpr, tt)

Visualiseerige analüüsi tulemused

Nüüd loome andmeraamid, mida oma visualiseerimiseks kasutame. Iga andmekaader sisaldab iga andmevoo (BBO, NBBO) viiest ajaintervallist ühe tsitaate:

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

Järgmistes jaotistes pakume näidiskoodi erinevate visualisatsioonide loomiseks.

Enne tehingut joonistage QS ja NBBO

Kasutage järgmist koodi noteeritud hinnavahe ja NBBO joonistamiseks enne tehingut:

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

Joonistage iga turu jaoks QS ja pärast tehingut NBBO

Kasutage järgmist koodi, et joonistada noteeritud hinnavahe iga turu ja NBBO kohta kohe pärast tehingut:

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

Joonistage QS iga ajaintervalli ja iga turu jaoks BBO jaoks

Kasutage järgmist koodi, et joonistada noteeritud hinnavahe iga ajaintervalli ja iga BBO turu jaoks:

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

Joonistage ES iga ajaintervalli ja BBO turu jaoks

Kasutage BBO iga ajaintervalli ja turu tegeliku hinnavahe joonistamiseks järgmist koodi:

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

Joonistage EQF iga ajaintervalli ja BBO turu jaoks

Kasutage BBO iga ajaintervalli ja turu tegeliku/noteeritud hinnavahe joonistamiseks järgmist koodi:

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 arvutustulemused

Kui käivitate koodiploki, määrab Athena Spark automaatselt, mitu DPU-d see arvutuse lõpuleviimiseks vajab. Viimases koodiplokis, kus me kutsume tca_analysis funktsioon, anname tegelikult Sparkile korralduse andmeid töödelda ja seejärel teisendame saadud Sparki andmeraamid Panda andmekaadriteks. See on analüüsi kõige intensiivsem töötlemise osa ja kui Athena Spark seda plokki käivitab, näitab see edenemisriba, kulunud aega ja seda, mitu DPU-d praegu andmeid töötleb. Näiteks järgmises arvutuses kasutab Athena Spark 18 DPU-d.

Kui konfigureerite oma Athena Spark sülearvuti, saate määrata maksimaalse DPU-de arvu, mida see saab kasutada. Vaikimisi on 20 DPU-d, kuid katsetasime seda arvutust 10, 20 ja 40 DPU-ga, et näidata, kuidas Athena Spark analüüsi käivitamiseks automaatselt skaleerub. Märkasime, et Athena Spark skaleerib lineaarselt, kuludes 15 minutit ja 21 sekundit, kui sülearvuti oli konfigureeritud maksimaalselt 10 DPU-ga, 8 minutit ja 23 sekundit, kui sülearvuti oli konfigureeritud 20 DPU-ga ning 4 minutit ja 44 sekundit, kui sülearvuti oli konfigureeritud. konfigureeritud 40 DPU-ga. Kuna Athena Spark võtab tasu DPU kasutuse põhjal sekundilise täpsusega, on nende arvutuste maksumus sarnane, kuid kui määrate suurema maksimaalse DPU väärtuse, saab Athena Spark analüüsi tulemuse palju kiiremini tagastada. Athena Sparki hinnakujunduse kohta lisateabe saamiseks klõpsake nuppu siin.

Järeldus

Selles postituses näitasime, kuidas saate Athena Sparki abil tehingukulude analüüsi tegemiseks kasutada LSEG-i Tick History-PCAP-i kõrgtäpsusega OPRA andmeid. OPRA andmete õigeaegne kättesaadavus koos Amazon S3 jaoks mõeldud AWS Data Exchange'i juurdepääsetavuse uuendustega vähendab strateegiliselt analüüsimiseks kuluvat aega ettevõtetel, kes soovivad luua kriitiliste kauplemisotsuste jaoks praktilisi teadmisi. OPRA genereerib iga päev umbes 7 TB normaliseeritud Parketi andmeid ja infrastruktuuri haldamine, et pakkuda OPRA andmetel põhinevat analüüsi, on keeruline.

Athena skaleeritavus puukide ajaloo suuremahulise andmetöötluse haldamisel – PCAP OPRA andmete jaoks muudab selle kaalukaks valikuks organisatsioonidele, kes otsivad AWS-is kiireid ja skaleeritavaid analüüsilahendusi. See postitus näitab sujuvat koostoimet AWS-i ökosüsteemi ja Tick History-PCAP andmete vahel ning seda, kuidas finantsasutused saavad seda sünergiat ära kasutada, et juhtida andmepõhist otsuste tegemist kriitiliste kauplemis- ja investeerimisstrateegiate jaoks.

Autoritest

Pramod Nayak on LSEG madala latentsusajaga rühma tootehalduse direktor. Pramodil on üle 10-aastane kogemus finantstehnoloogia valdkonnas, keskendudes tarkvaraarendusele, analüütikale ja andmehaldusele. Pramod on endine tarkvarainsener ja kirglik turuandmete ja kvantitatiivse kauplemise vastu.

LakshmiKanth Mannem on LSEG madala latentsusajaga grupi tootejuht. Ta keskendub madala latentsusega turu andmetööstuse andme- ja platvormtoodetele. LakshmiKanth aitab klientidel luua kõige optimaalsemaid lahendusi nende turuandmete vajadustele.

Vivek Aggarwal on vanem andmeinsener LSEG madala latentsusajaga rühmas. Vivek tegeleb hõivatud turuandmevoogude ja võrdlusandmevoogude töötlemiseks ja edastamiseks mõeldud andmekanalite arendamise ja hooldamisega.

Alket Memushaj on AWS-i finantsteenuste turu arendusmeeskonna peaarhitekt. Alket vastutab tehnilise strateegia eest, tehes koostööd partnerite ja klientidega, et juurutada AWS-i pilve ka kõige nõudlikumad kapitaliturgude töökoormused.

Ajatempel:

Veel alates AWSi suured andmed