Zephyrnet-logo

Generatieve data-intelligentie

Big data

De marktdynamiek beheersen: analyse van transactiekosten transformeren met ultraprecieze Tick History – PCAP en Amazon Athena voor Apache Spark | Amazon-webservices

Heruitgegeven door Plato
Heruitgegeven door Plato

Datum:

Aantal keer bekeken: 144

Dit bericht is geschreven in samenwerking met Pramod Nayak, LakshmiKanth Mannem en Vivek Aggarwal van de Low Latency Group van LSEG.

Transactiekostenanalyse (TCA) wordt veel gebruikt door handelaren, portefeuillebeheerders en makelaars voor analyse vóór en na de handel, en helpt hen de transactiekosten en de effectiviteit van hun handelsstrategieën te meten en te optimaliseren. In dit bericht analyseren we de bied-laatspreads van de opties LSEG-tekengeschiedenis – PCAP dataset gebruikt Amazon Athena voor Apache Spark. We laten u zien hoe u toegang krijgt tot gegevens, aangepaste functies definieert om op gegevens toe te passen, de gegevensset opvraagt ​​en filtert en de resultaten van de analyse visualiseert, allemaal zonder dat u zich zorgen hoeft te maken over het opzetten van infrastructuur of het configureren van Spark, zelfs voor grote datasets.

Achtergrond

Options Price Reporting Authority (OPRA) fungeert als een cruciale verwerker van effecteninformatie en verzamelt, consolideert en verspreidt laatste verkooprapporten, koersen en relevante informatie voor Amerikaanse opties. Met 18 actieve Amerikaanse optiebeurzen en meer dan 1.5 miljoen in aanmerking komende contracten speelt OPRA een cruciale rol bij het verstrekken van uitgebreide marktgegevens.

Op 5 februari 2024 zal de Securities Industry Automation Corporation (SIAC) de OPRA-feed upgraden van 48 naar 96 multicast-kanalen. Deze verbetering heeft tot doel de symbooldistributie en het gebruik van lijncapaciteit te optimaliseren als reactie op de escalerende handelsactiviteit en volatiliteit op de Amerikaanse optiemarkt. SIAC heeft aanbevolen dat bedrijven zich voorbereiden op piekdatasnelheden tot 37.3 GBits per seconde.

Ondanks dat de upgrade het totale volume aan gepubliceerde gegevens niet onmiddellijk verandert, kan OPRA gegevens aanzienlijk sneller verspreiden. Deze transitie is van cruciaal belang om tegemoet te komen aan de eisen van de dynamische optiemarkt.

OPRA valt op als een van de meest omvangrijke feeds, met een piek van 150.4 miljard berichten op één dag in het derde kwartaal van 3 en een capaciteitsvereiste van 2023 miljard berichten op één dag. Het vastleggen van elk afzonderlijk bericht is van cruciaal belang voor analyse van transactiekosten, monitoring van de marktliquiditeit, evaluatie van handelsstrategieën en marktonderzoek.

Over de gegevens

LSEG-tekengeschiedenis – PCAP is een cloudgebaseerde opslagplaats van meer dan 30 PB, die ultrahoge kwaliteit wereldwijde marktgegevens bevat. Deze gegevens worden nauwgezet rechtstreeks in de uitwisselingsdatacentra vastgelegd, waarbij gebruik wordt gemaakt van redundante vastlegprocessen die strategisch zijn gepositioneerd in de belangrijkste primaire en back-upuitwisselingsdatacentra over de hele wereld. De vastlegtechnologie van LSEG zorgt voor verliesvrije gegevensvastlegging en maakt gebruik van een GPS-tijdbron voor tijdstempelprecisie van nanoseconden. Bovendien worden geavanceerde dataarbitragetechnieken gebruikt om eventuele datalacunes naadloos op te vullen. Na het vastleggen ondergaan de gegevens een nauwgezette verwerking en arbitrage, en worden vervolgens genormaliseerd naar het Parquet-formaat met behulp van LSEG's realtime ultradirect (RTUD) voerbehandelaars.

Het normalisatieproces, dat een integraal onderdeel is van het voorbereiden van de gegevens voor analyse, genereert tot 6 TB aan gecomprimeerde Parquet-bestanden per dag. De enorme hoeveelheid gegevens wordt toegeschreven aan het allesomvattende karakter van OPRA, dat meerdere beurzen omvat en talrijke optiecontracten bevat die worden gekenmerkt door uiteenlopende kenmerken. De toegenomen marktvolatiliteit en marktmakingactiviteiten op de optiebeurzen dragen verder bij aan de hoeveelheid gegevens die op OPRA worden gepubliceerd.

De kenmerken van Tick History – PCAP stellen bedrijven in staat verschillende analyses uit te voeren, waaronder de volgende:

  • Analyse vóór de handel – Evalueer de potentiële handelsimpact en verken verschillende uitvoeringsstrategieën op basis van historische gegevens
  • Evaluatie na de handel – Meet de werkelijke uitvoeringskosten aan de hand van benchmarks om de prestaties van uitvoeringsstrategieën te beoordelen
  • Geoptimaliseerde uitvoering – Verfijn uitvoeringsstrategieën op basis van historische marktpatronen om de marktimpact te minimaliseren en de totale handelskosten te verlagen
  • Risicomanagement – Identificeer slippatronen, identificeer uitschieters en beheer proactief de risico's die verband houden met handelsactiviteiten
  • Prestatie attributie – Scheid de impact van handelsbeslissingen van investeringsbeslissingen bij het analyseren van portefeuilleprestaties

De LSEG Tick History – PCAP-dataset is beschikbaar in AWS-gegevensuitwisseling en is toegankelijk via AWS Marketplace. Met AWS-gegevensuitwisseling voor Amazon S3, heeft u rechtstreeks toegang tot PCAP-gegevens vanuit LSEG's Amazon eenvoudige opslagservice (Amazon S3)-buckets, waardoor bedrijven niet langer hun eigen kopie van de gegevens hoeven op te slaan. Deze aanpak stroomlijnt het gegevensbeheer en de opslag, waardoor klanten onmiddellijke toegang krijgen tot hoogwaardige PCAP of genormaliseerde gegevens met gebruiksgemak, integratie en aanzienlijke besparingen op gegevensopslag.

Athena voor Apache Spark

Voor analytische inspanningen, Athena voor Apache Spark biedt een vereenvoudigde notebookervaring die toegankelijk is via de Athena-console of Athena API's, waardoor u interactieve Apache Spark-applicaties kunt bouwen. Met een geoptimaliseerde Spark-runtime helpt Athena bij de analyse van petabytes aan gegevens door het aantal Spark-engines dynamisch te schalen in minder dan een seconde. Bovendien zijn veelgebruikte Python-bibliotheken zoals Panda's en NumPy naadloos geïntegreerd, waardoor ingewikkelde applicatielogica kan worden gecreëerd. De flexibiliteit strekt zich uit tot de import van aangepaste bibliotheken voor gebruik in notebooks. Athena for Spark is geschikt voor de meeste open-dataformaten en is naadloos geïntegreerd met de AWS lijm Gegevenscatalogus.

dataset

Voor deze analyse hebben we de LSEG Tick History – PCAP OPRA-dataset van 17 mei 2023 gebruikt. Deze dataset bestaat uit de volgende componenten:

  • Beste bied- en laatprijs (BBO) – Rapporteert het hoogste bod en de laagste vraag voor een effect op een bepaalde beurs
  • Nationaal beste bod en laat (NBBO) – Rapporteert het hoogste bod en de laagste vraag voor een effect op alle beurzen
  • Trades – Registreert voltooide transacties op alle beurzen

De dataset omvat de volgende datavolumes:

  • Trades – 160 MB verdeeld over ongeveer 60 gecomprimeerde Parquet-bestanden
  • BBO – 2.4 TB verdeeld over ongeveer 300 gecomprimeerde Parquet-bestanden
  • NBBO – 2.8 TB verdeeld over ongeveer 200 gecomprimeerde Parquet-bestanden

Analyse overzicht

Het analyseren van OPRA Tick History-gegevens voor Transaction Cost Analysis (TCA) omvat het nauwkeurig onderzoeken van marktnoteringen en transacties rond een specifiek handelsevenement. We gebruiken de volgende statistieken als onderdeel van dit onderzoek:

  • Geciteerde spread (QS) – Berekend als het verschil tussen de BBO-vraag en het BBO-bod
  • Effectieve spreiding (ES) – Berekend als het verschil tussen de handelsprijs en het middelpunt van de BBO (BBO-bod + (BBO ask – BBO-bod)/2)
  • Effectieve/geciteerde spread (EQF) – Berekend als (ES / QS) * 100

We berekenen deze spreads vóór de transactie en bovendien met vier intervallen na de transactie (net erna, 1 seconde, 10 seconden en 60 seconden na de transactie).

Configureer Athena voor Apache Spark

Voer de volgende stappen uit om Athena voor Apache Spark te configureren:

  1. Op de Athena-console, onder Startselecteer Analyseer uw gegevens met PySpark en Spark SQL.
  2. Als dit de eerste keer is dat u Athena Spark gebruikt, kies dan Werkgroep maken.
  3. Voor Werkgroep naam¸ voer een naam in voor de werkgroep, bijvoorbeeld tca-analysis.
  4. In het Analytics-engine sectie, selecteer Apache Spark.
  5. In het Aanvullende configuraties sectie, u kunt kiezen Standaardinstellingen gebruiken of geef een gewoonte aan AWS Identiteits- en toegangsbeheer (IAM)-rol en Amazon S3-locatie voor berekeningsresultaten.
  6. Kies Werkgroep maken.
  7. Nadat u de werkgroep hebt gemaakt, navigeert u naar de Notitieboekjes tab en kies Maak een notitieboekje.
  8. Voer een naam in voor uw notitieblok, bijvoorbeeld tca-analysis-with-tick-history.
  9. Kies creëren om uw notitieboekje te maken.

Start uw notitieboekje

Als u al een Spark-werkgroep hebt gemaakt, selecteert u Start de notitieboekjeeditor voor Start.


Nadat uw notitieblok is aangemaakt, wordt u doorgestuurd naar de interactieve notitieboekeditor.


Nu kunnen we de volgende code aan onze notebook toevoegen en uitvoeren.

Maak een analyse

Voer de volgende stappen uit om een ​​analyse te maken:

  • Gemeenschappelijke bibliotheken importeren:
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go

  • Creëer onze dataframes voor BBO, NBBO en transacties:
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 kunnen we een transactie identificeren die we kunnen gebruiken voor de analyse van transactiekosten:
filtered_trades = spark.sql("select Product, Price,Quantity, ReceiptTimestamp, MarketParticipant from trades")

We krijgen de volgende uitvoer:

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

We gebruiken de gemarkeerde handelsinformatie in de toekomst voor het handelsproduct (tp), de handelsprijs (tpr) en de handelstijd (tt).

  • Hier creëren we een aantal helperfuncties voor onze analyse
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

  • In de volgende functie creëren we de dataset die alle koersen voor en na de transactie bevat. Athena Spark bepaalt automatisch hoeveel DPU's moeten worden gestart voor het verwerken van onze dataset.
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

  • Laten we nu de TCA-analysefunctie oproepen met de informatie van onze geselecteerde transactie:
tp = "QQQ 230518C00329000"
tpr = 1.16
tt = 1684338579104713924
c = get_tca_analysis_via_df_single_query(tp, tpr, tt)

Visualiseer de analyseresultaten

Laten we nu de dataframes maken die we voor onze visualisatie gebruiken. Elk dataframe bevat offertes voor een van de vijf tijdsintervallen voor elke datafeed (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)]

In de volgende secties bieden we voorbeeldcode om verschillende visualisaties te maken.

Plot QS en NBBO vóór de transactie

Gebruik de volgende code om de genoteerde spread en NBBO vóór de transactie in kaart te brengen:

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

Teken QS voor elke markt en NBBO na de transactie

Gebruik de volgende code om de genoteerde spread voor elke markt en NBBO onmiddellijk na de transactie in kaart te brengen:

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

Teken QS voor elk tijdsinterval en elke markt voor BBO

Gebruik de volgende code om de genoteerde spread voor elk tijdsinterval en elke markt voor BBO in kaart te brengen:

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

Teken ES voor elk tijdsinterval en markt voor BBO

Gebruik de volgende code om de effectieve spread voor elk tijdsinterval en elke markt voor BBO in kaart te brengen:

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

Teken het EQF voor elk tijdsinterval en elke markt voor BBO

Gebruik de volgende code om de effectieve/geciteerde spread voor elk tijdsinterval en elke markt voor BBO in kaart te brengen:

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

Wanneer u een codeblok uitvoert, bepaalt Athena Spark automatisch hoeveel DPU's er nodig zijn om de berekening te voltooien. In het laatste codeblok, waar we de tca_analysis functie, instrueren we Spark feitelijk om de gegevens te verwerken, en vervolgens zetten we de resulterende Spark-dataframes om in Pandas-dataframes. Dit vormt het meest intensieve verwerkingsgedeelte van de analyse en wanneer Athena Spark dit blok uitvoert, worden de voortgangsbalk, de verstreken tijd en het aantal DPU's weergegeven dat momenteel gegevens verwerken. In de volgende berekening gebruikt Athena Spark bijvoorbeeld 18 DPU's.

Wanneer u uw Athena Spark-notebook configureert, heeft u de mogelijkheid om het maximale aantal DPU's in te stellen dat deze kan gebruiken. De standaardwaarde is 20 DPU's, maar we hebben deze berekening getest met 10, 20 en 40 DPU's om aan te tonen hoe Athena Spark automatisch schaalt om onze analyse uit te voeren. We hebben vastgesteld dat Athena Spark lineair schaalt, wat 15 minuten en 21 seconden duurt als de notebook is geconfigureerd met maximaal 10 DPU's, 8 minuten en 23 seconden als de notebook is geconfigureerd met 20 DPU's, en 4 minuten en 44 seconden als de notebook is geconfigureerd geconfigureerd met 40 DPU's. Omdat Athena Spark kosten in rekening brengt op basis van DPU-gebruik, zijn de kosten van deze berekeningen vergelijkbaar per seconde, maar als u een hogere maximale DPU-waarde instelt, kan Athena Spark het resultaat van de analyse veel sneller retourneren. Klik voor meer informatie over de prijzen van Athena Spark hier.

Conclusie

In dit bericht hebben we laten zien hoe u hoogwaardige OPRA-gegevens van LSEG's Tick History-PCAP kunt gebruiken om transactiekostenanalyses uit te voeren met Athena Spark. De tijdige beschikbaarheid van OPRA-gegevens, aangevuld met toegankelijkheidsinnovaties van AWS Data Exchange voor Amazon S3, verkort op strategische wijze de tijd die nodig is voor analyse voor bedrijven die bruikbare inzichten willen creëren voor cruciale handelsbeslissingen. OPRA genereert elke dag ongeveer 7 TB aan genormaliseerde Parquet-gegevens, en het beheren van de infrastructuur om analyses te bieden op basis van OPRA-gegevens is een uitdaging.

De schaalbaarheid van Athena bij het verwerken van grootschalige gegevensverwerking voor Tick History – PCAP voor OPRA-gegevens maakt het een aantrekkelijke keuze voor organisaties die op zoek zijn naar snelle en schaalbare analyseoplossingen in AWS. Dit bericht toont de naadloze interactie tussen het AWS-ecosysteem en Tick History-PCAP-gegevens en hoe financiële instellingen kunnen profiteren van deze synergie om datagestuurde besluitvorming voor cruciale handels- en investeringsstrategieën te stimuleren.

Over de auteurs

Pramod Najak is directeur Product Management van de Low Latency Group bij LSEG. Pramod heeft meer dan 10 jaar ervaring in de financiële technologie-industrie, met de nadruk op softwareontwikkeling, analyse en gegevensbeheer. Pramod is een voormalig software-ingenieur en gepassioneerd door marktgegevens en kwantitatieve handel.

LakshmiKanth Mannem is productmanager bij de Low Latency Group van LSEG. Hij richt zich op data- en platformproducten voor de marktdata-industrie met lage latentie. LakshmiKanth helpt klanten bij het bouwen van de meest optimale oplossingen voor hun marktgegevensbehoeften.

Vivek Aggarwal is een Senior Data Engineer in de Low Latency Group van LSEG. Vivek werkt aan het ontwikkelen en onderhouden van datapijplijnen voor de verwerking en levering van vastgelegde marktdatafeeds en referentiedatafeeds.

Alket Memushaj is hoofdarchitect in het Financial Services Market Development-team van AWS. Alket is verantwoordelijk voor de technische strategie en werkt samen met partners en klanten om zelfs de meest veeleisende kapitaalmarktworkloads in de AWS Cloud te implementeren.

spot_img

Laatste intelligentie

spot_img

Copyright @ 2024 Plato Technologies Inc.