Markkinadynamiikan hallinta: Transaktiokustannusanalytiikan muuttaminen erittäin tarkalla Tick Historylla – PCAP ja Amazon Athena Apache Sparkille | Amazon Web Services

Markkinadynamiikan hallinta: Transaktiokustannusanalytiikan muuttaminen erittäin tarkalla Tick Historylla – PCAP ja Amazon Athena Apache Sparkille | Amazon Web Services

Aikaleima: 31. tammikuuta 2024 12
Lähdesolmu: 3091357

Tämä viesti on kirjoittanut Pramod Nayak, LakshmiKanth Mannem ja Vivek Aggarwal LSEG:n Low Latency Groupista.

Kauppiaat, salkunhoitajat ja välittäjät käyttävät laajasti transaktiokustannusanalyysiä (TCA) kauppaa edeltävään ja kaupan jälkeiseen analysointiin, ja se auttaa heitä mittaamaan ja optimoimaan transaktiokustannuksia ja kaupankäyntistrategioidensa tehokkuutta. Tässä viestissä analysoimme vaihtoehtoja tarjous-kysymyseroja LSEG Tick History – PCAP tietojoukko käyttäen Amazon Athena Apache Sparkille. Näytämme sinulle, kuinka pääset käsiksi tietoihin, määrität tietoihin sovellettavia mukautettuja toimintoja, teemme kyselyjä ja suodatamme tietojoukkoja sekä visualisoimme analyysin tulokset ilman, että sinun tarvitsee huolehtia infrastruktuurin perustamisesta tai Sparkin määrittämisestä, jopa suurille tietojoukoille.

Tausta

Optioiden hintaraportointiviranomainen (OPRA) toimii tärkeänä arvopaperitietojen käsittelijänä, joka kerää, yhdistää ja jakaa viimeisimpiä myyntiraportteja, tarjouksia ja asiaankuuluvia tietoja Yhdysvaltain optioista. OPRAlla on 18 aktiivista Yhdysvaltain optiopörssiä ja yli 1.5 miljoonaa hyväksyttyä sopimusta, joten OPRAlla on keskeinen rooli kattavien markkinatietojen tarjoamisessa.

5. helmikuuta 2024 Securities Industry Automation Corporation (SIAC) päivittää OPRA-syötteen 48:sta 96 monilähetyskanavaan. Tällä parannuksella pyritään optimoimaan symbolien jakelu ja linjakapasiteetin käyttöaste vastauksena lisääntyvään kaupankäyntiin ja epävakauteen Yhdysvaltain optiomarkkinoilla. SIAC on suositellut, että yritykset valmistautuvat huippunopeuteen, joka on jopa 37.3 gigatavua sekunnissa.

Huolimatta siitä, että päivitys ei heti muuta julkaistujen tietojen kokonaismäärää, se antaa OPRAlle mahdollisuuden levittää tietoja huomattavasti nopeammin. Tämä siirtymä on ratkaisevan tärkeä dynaamisten optiomarkkinoiden vaatimuksiin vastaamiseksi.

OPRA erottuu joukosta yhdeksi laajimmista syötteistä, sillä sen huippu on 150.4 miljardia viestiä yhdessä päivässä vuoden 3 kolmannella neljänneksellä ja kapasiteettivaatimus 2023 miljardia viestiä yhden päivän aikana. Jokaisen viestin tallentaminen on tärkeää transaktiokustannusanalyysin, markkinoiden likviditeetin seurannan, kaupankäyntistrategian arvioinnin ja markkinatutkimuksen kannalta.

Tietoja tiedoista

LSEG Tick History – PCAP on pilvipohjainen arkisto, jossa on yli 30 PB ja joka sisältää erittäin korkealaatuista globaalia markkinatietoa. Nämä tiedot kerätään huolellisesti suoraan vaihtotietokeskuksissa käyttämällä redundantteja talteenottoprosesseja, jotka on strategisesti sijoitettu tärkeimpiin ensisijaisiin ja varatietokeskuksiin maailmanlaajuisesti. LSEG:n sieppaustekniikka varmistaa häviöttömän tiedonkeruun ja käyttää GPS-aikalähdettä nanosekunnin aikaleiman tarkkuuteen. Lisäksi kehittyneitä tiedon arbitraasitekniikoita käytetään saumattomasti täyttämään kaikki tietoaukot. Sieppauksen jälkeen tiedot käsitellään huolellisesti ja sovitetaan, minkä jälkeen ne normalisoidaan parkettimuotoon käyttämällä LSEG:n Real Time Ultra Direct (RTUD) rehunkäsittelijät.

Normalisointiprosessi, joka on olennainen osa tietojen valmistelua analysointia varten, tuottaa jopa 6 Tt pakattuja parkettitiedostoja päivässä. Tietojen valtava määrä johtuu OPRA:n kattavasta luonteesta, joka kattaa useita vaihtoja ja sisältää lukuisia optiosopimuksia, joille on ominaista erilaiset attribuutit. Markkinoiden lisääntynyt volatiliteetti ja markkinatakaus optiopörsseissä lisäävät edelleen OPRAsta julkaistujen tietojen määrää.

Tick ​​History – PCAP:n ominaisuudet antavat yrityksille mahdollisuuden suorittaa erilaisia ​​analyyseja, mukaan lukien seuraavat:

  • Kauppaa edeltävä analyysi – Arvioi mahdollisia kauppavaikutuksia ja tutki erilaisia ​​toteutusstrategioita historiatietoihin perustuen
  • Kaupan jälkeinen arviointi – Mittaa todelliset toteutuskustannukset vertailuarvoihin, jotta voit arvioida toteutusstrategioiden tehokkuutta
  • optimoitu teloitus – Hienosäädä toteutusstrategioita, jotka perustuvat historiallisiin markkinamalleihin minimoidaksesi markkinavaikutuksen ja alentaaksesi kaupankäynnin kokonaiskustannuksia
  • Riskienhallinta – Tunnista liukastumismallit, tunnista poikkeamat ja hallitse ennakoivasti kaupankäyntiin liittyviä riskejä
  • Suorituskyvyn vaikuttavuus – Erottele kaupankäyntipäätösten vaikutus sijoituspäätöksistä, kun analysoit salkun kehitystä

LSEG Tick History – PCAP-tietojoukko on saatavilla AWS-tiedonvaihto ja niihin pääsee käsiksi AWS Marketplace. Kanssa AWS Data Exchange Amazon S3:lle, voit käyttää PCAP-tietoja suoraan LSEG:stä Amazonin yksinkertainen tallennuspalvelu (Amazon S3) -ämpärit, jolloin yritysten ei tarvitse tallentaa omia kopioja tiedoista. Tämä lähestymistapa virtaviivaistaa tietojen hallintaa ja tallennusta tarjoamalla asiakkaille välittömän pääsyn korkealaatuisiin PCAP- tai normalisoituihin tietoihin helppokäyttöisenä, integroitavina ja huomattavia säästöjä tiedontallennustilassa.

Athena Apache Sparkille

Analyyttisiin pyrkimyksiin Athena Apache Sparkille tarjoaa yksinkertaisen kannettavan käyttökokemuksen, joka on käytettävissä Athena-konsolin tai Athena-sovellusliittymien kautta, jolloin voit rakentaa interaktiivisia Apache Spark -sovelluksia. Optimoidun Spark-ajoajan ansiosta Athena auttaa petatavujen datan analysoinnissa skaalaamalla dynaamisesti Spark-moottoreiden määrää alle sekunnissa. Lisäksi yleiset Python-kirjastot, kuten pandas ja NumPy, on integroitu saumattomasti, mikä mahdollistaa monimutkaisen sovelluslogiikan luomisen. Joustavuus ulottuu mukautettujen kirjastojen maahantuontiin muistikirjoissa käytettäväksi. Athena for Spark tukee useimpia avoimen datan formaatteja ja on saumattomasti integroitu AWS-liima Data Katalogi.

aineisto

Tässä analyysissä käytimme LSEG Tick History – PCAP OPRA -tietojoukkoa 17. toukokuuta 2023. Tämä tietojoukko sisältää seuraavat osat:

  • Paras tarjous (BBO) – Raportoi arvopaperin korkeimman tarjouksen ja alimman kysynnän tietyssä pörssissä
  • Kansallinen paras tarjous (NBBO) – Raportoi korkeimman tarjouksen ja alhaisimman arvopaperipyynnön kaikissa pörsseissä
  • kaupat – Kirjaa tehdyt kaupat kaikissa pörsseissä

Tietojoukko sisältää seuraavat tietomäärät:

  • kaupat – 160 Mt jaettu noin 60 pakattuun Parquet-tiedostoon
  • BBO – 2.4 TB jaettu noin 300 pakattuun parkettitiedostoon
  • NBBO – 2.8 TB jaettu noin 200 pakattuun parkettitiedostoon

Analyysin yleiskatsaus

OPRA Tick History -tietojen analysointi Transaction Cost Analysis (TCA) -analyysiä varten sisältää markkinanoteerausten ja -kauppojen tarkastelun tietyn kauppatapahtuman ympärillä. Käytämme seuraavia mittareita osana tätä tutkimusta:

  • Lainausero (QS) – Laskettu BBO-pyynnön ja BBO-tarjouksen erotuksena
  • Tehokas leviäminen (ES) – Lasketaan kauppahinnan ja BBO:n keskipisteen erotuksena (BBO-tarjous + (BBO-hinta – BBO-tarjous)/2)
  • Tehokas/lainattu ero (EQF) – Laskettu muodossa (ES / QS) * 100

Laskemme nämä erot ennen kauppaa ja lisäksi neljän välein kaupan jälkeen (juuri jälkeen, 1 sekunti, 10 sekuntia ja 60 sekuntia kaupan jälkeen).

Määritä Athena Apache Sparkille

Määritä Athena Apache Sparkille suorittamalla seuraavat vaiheet:

  1. Athena-konsolissa, alla Aloitavalitse Analysoi tietosi PySparkilla ja Spark SQL:llä.
  2. Jos tämä on ensimmäinen kerta, kun käytät Athena Sparkia, valitse Luo työryhmä.
  3. varten Työryhmän nimi¸ anna työryhmälle nimi, esim tca-analysis.
  4. In Analytics-moottori , valitse Apache Spark.
  5. In Lisäkokoonpanot osiosta, voit valita Käytä oletusasetuksia tai tarjoa mukautettua AWS-henkilöllisyyden ja käyttöoikeuksien hallinta (IAM) rooli ja Amazon S3 -sijainti laskentatuloksia varten.
  6. Valita Luo työryhmä.
  7. Kun olet luonut työryhmän, siirry kohtaan Kannettavat välilehti ja valitse Luo muistikirja.
  8. Anna muistikirjallesi nimi, esim tca-analysis-with-tick-history.
  9. Valita luoda muistikirjan luomiseen.

Käynnistä muistikirjasi

Jos olet jo luonut Spark-työryhmän, valitse Käynnistä muistikirjan editori varten Aloita.


Kun muistikirja on luotu, sinut ohjataan interaktiiviseen muistikirjan editoriin.


Nyt voimme lisätä ja suorittaa seuraavan koodin muistikirjaamme.

Luo analyysi

Luo analyysi suorittamalla seuraavat vaiheet:

  • Tuo yleiset kirjastot:
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go

  • Luo tietokehyksemme BBO:lle, NBBO:lle ja kaupoille:
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")

  • Nyt voimme tunnistaa kaupan, jota käytetään transaktiokustannusanalyysissä:
filtered_trades = spark.sql("select Product, Price,Quantity, ReceiptTimestamp, MarketParticipant from trades")

Saamme seuraavan tuloksen:

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

Käytämme jatkossa korostettuja kauppatietoja kauppatuotteelle (tp), kauppahinnalle (tpr) ja kauppaajalle (tt).

  • Täällä luomme useita aputoimintoja analyysiämme varten
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

  • Seuraavassa funktiossa luomme tietojoukon, joka sisältää kaikki tarjoukset ennen kauppaa ja sen jälkeen. Athena Spark määrittää automaattisesti, kuinka monta DPU:ta käynnistetään datajoukkomme käsittelyä varten.
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

  • Kutsutaan nyt TCA-analyysitoimintoa valitun kaupan tiedoilla:
tp = "QQQ 230518C00329000"
tpr = 1.16
tt = 1684338579104713924
c = get_tca_analysis_via_df_single_query(tp, tpr, tt)

Visualisoi analyysin tulokset

Luodaan nyt tietokehykset, joita käytämme visualisointiimme. Jokainen datakehys sisältää lainausmerkit yhdelle viidestä aikavälistä jokaiselle tietosyötteen (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)]

Seuraavissa osioissa tarjoamme esimerkkikoodin erilaisten visualisointien luomiseen.

Piirrä QS ja NBBO ennen kauppaa

Käytä seuraavaa koodia piirtääksesi noteeratun eron ja NBBO:n ennen kauppaa:

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

Piirrä QS kullekin markkinalle ja NBBO kaupan jälkeen

Käytä seuraavaa koodia kuvaamaan kunkin markkinan ja NBBO:n noteerattu ero välittömästi kaupan jälkeen:

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

Piirrä QS kullekin aikavälille ja jokaiselle BBO-markkinalle

Käytä seuraavaa koodia piirtääksesi kunkin aikavälin ja kunkin BBO-markkinoiden noteeratun eron:

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

Piirrä ES kullekin aikavälille ja BBO-markkinalle

Käytä seuraavaa koodia piirtääksesi kunkin aikavälin ja BBO:n markkinoiden tehokkaan erotuksen:

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

Piirrä EQF kullekin aikavälille ja BBO-markkinalle

Käytä seuraavaa koodia piirtääksesi tehollisen/noteeratun eron kullekin aikavälille ja BBO:lle:

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 -laskennan suorituskyky

Kun suoritat koodilohkon, Athena Spark määrittää automaattisesti, kuinka monta DPU:ta se tarvitsee laskennan suorittamiseen. Viimeisessä koodilohkossa, jossa kutsumme tca_analysis toiminto, itse asiassa ohjeistamme Sparkia käsittelemään tiedot ja muunnamme sitten saadut Spark-tietokehykset Pandas-tietokehyksiksi. Tämä on analyysin intensiivisin käsittelyosa, ja kun Athena Spark suorittaa tämän lohkon, se näyttää edistymispalkin, kuluneen ajan ja kuinka monta DPU:ta käsittelee tietoja tällä hetkellä. Esimerkiksi seuraavassa laskelmassa Athena Spark käyttää 18 DPU:ta.

Kun määrität Athena Spark -kannettavan, voit määrittää sen käyttämien DPU-yksiköiden enimmäismäärän. Oletusarvo on 20 DPU:ta, mutta testasimme tämän laskelman 10, 20 ja 40 DPU:lla osoittaaksemme, kuinka Athena Spark skaalautuu automaattisesti suorittaakseen analyysimme. Havaitsimme, että Athena Spark skaalautuu lineaarisesti, ja kesti 15 minuuttia ja 21 sekuntia, kun kannettavassa tietokoneessa oli enintään 10 DPU:ta, 8 minuuttia ja 23 sekuntia, kun kannettavassa oli 20 DPU:ta, ja 4 minuuttia ja 44 sekuntia, kun tietokone oli konfiguroitu 40 DPU:lla. Koska Athena Spark veloittaa DPU:n käytön perusteella, sekuntitarkkuudella, näiden laskelmien kustannukset ovat samanlaiset, mutta jos asetat korkeamman DPU:n maksimiarvon, Athena Spark voi palauttaa analyysin tuloksen paljon nopeammin. Saat lisätietoja Athena Spark -hinnoittelusta napsauttamalla tätä.

Yhteenveto

Tässä viestissä osoitimme, kuinka voit käyttää LSEG:n Tick History-PCAP:n korkealaatuisia OPRA-tietoja suorittaaksesi transaktiokustannusten analytiikkaa Athena Sparkilla. OPRA-tietojen oikea-aikainen saatavuus yhdistettynä AWS Data Exchangen saavutettavuusinnovaatioihin Amazon S3:lle vähentää strategisesti analytiikkaan kuluvaa aikaa yrityksillä, jotka haluavat luoda käyttökelpoisia oivalluksia kriittisiin kaupankäyntipäätöksiin. OPRA tuottaa noin 7 teratavua normalisoitua parkettidataa joka päivä, ja infrastruktuurin hallinta OPRA-dataan perustuvan analytiikan tarjoamiseksi on haastavaa.

Athenen skaalautuvuus Tick History - PCAP for OPRA -tietojen suuren mittakaavan tietojenkäsittelyssä tekee siitä houkuttelevan valinnan organisaatioille, jotka etsivät nopeita ja skaalautuvia analytiikkaratkaisuja AWS:ssä. Tämä viesti näyttää saumattoman vuorovaikutuksen AWS-ekosysteemin ja Tick History-PCAP -tietojen välillä ja kuinka rahoituslaitokset voivat hyödyntää tätä synergiaa ohjatakseen tietopohjaista päätöksentekoa kriittisissä kaupankäynti- ja sijoitusstrategioissa.

Tietoja Tekijät

Pramod Nayak on LSEG:n Low Latency Groupin tuotehallinnan johtaja. Pramodilla on yli 10 vuoden kokemus rahoitusteknologia-alalta, keskittyen ohjelmistokehitykseen, analytiikkaan ja tiedonhallintaan. Pramod on entinen ohjelmistosuunnittelija ja intohimoinen markkinatiedoista ja kvantitatiivisesta kaupankäynnistä.

LakshmiKanth Mannem on tuotepäällikkö LSEG:n Low Latency Groupissa. Hän keskittyy data- ja alustatuotteisiin alhaisen latenssin markkinoiden datateollisuudelle. LakshmiKanth auttaa asiakkaita rakentamaan optimaaliset ratkaisut markkinatietotarpeisiinsa.

Vivek Aggarwal on vanhempi tietoinsinööri LSEG:n Low Latency Groupissa. Vivek kehittää ja ylläpitää dataputkia kaapattujen markkinatietosyötteiden ja viitetietosyötteiden käsittelyä ja toimitusta varten.

Alket Memushaj on pääarkkitehti AWS:n rahoituspalvelumarkkinoiden kehitystiimissä. Alket vastaa teknisestä strategiasta ja työskentelee kumppaneiden ja asiakkaiden kanssa vaativimpienkin pääomamarkkinoiden työkuormien käyttöönottamiseksi AWS-pilveen.

Aikaleima:

Lisää aiheesta AWS Big Data