A piaci dinamika elsajátítása: A tranzakciós költségelemzés átalakítása az ultrapontos Tick History segítségével – PCAP és Amazon Athena az Apache Spark számára | Amazon webszolgáltatások

A piaci dinamika elsajátítása: A tranzakciós költségelemzés átalakítása az ultrapontos Tick History segítségével – PCAP és Amazon Athena az Apache Spark számára | Amazon webszolgáltatások

Időbélyeg: 31. január 2024. 12:20
Forrás csomópont: 3091357

Ezt a bejegyzést Pramod Nayak, LakshmiKanth Mannem és Vivek Aggarwal írta az LSEG Low Latency Group-ból.

A tranzakciós költségelemzést (TCA) a kereskedők, portfóliókezelők és brókerek széles körben használják kereskedés előtti és utáni elemzéshez, és segít mérni és optimalizálni a tranzakciós költségeket és kereskedési stratégiáik hatékonyságát. Ebben a bejegyzésben elemezzük a licit-ask spreadeket a LSEG Tick History – PCAP adatkészlet használatával Amazon Athena az Apache Spark számára. Megmutatjuk, hogyan férhet hozzá az adatokhoz, hogyan határozhat meg az adatokra alkalmazható egyedi függvényeket, hogyan kérdezheti le és szűrheti az adatkészletet, és vizualizálhatja az elemzés eredményeit – mindezt anélkül, hogy az infrastruktúra beállításával vagy a Spark konfigurálásával kellene aggódnia, még nagy adatkészletek esetén is.

Háttér

Az Options Price Reporting Authority (OPRA) kulcsfontosságú értékpapír-információ-feldolgozóként szolgál, gyűjti, konszolidálja és terjeszti az utolsó eladási jelentéseket, árajánlatokat és az egyesült államokbeli opciókkal kapcsolatos vonatkozó információkat. 18 aktív amerikai opciós tőzsdével és több mint 1.5 millió jogosult szerződéssel az OPRA kulcsszerepet játszik az átfogó piaci adatok biztosításában.

5. február 2024-én a Securities Industry Automation Corporation (SIAC) 48-ról 96 multicast csatornára frissíti az OPRA feedet. Ennek a fejlesztésnek az a célja, hogy optimalizálja a szimbólumeloszlást és a vonalkapacitás kihasználtságát, válaszul a kereskedési tevékenység fokozódására és az amerikai opciós piac volatilitására. A SIAC azt javasolta, hogy a cégek készüljenek fel a legfeljebb 37.3 GB/s adatátviteli sebességre.

Annak ellenére, hogy a frissítés nem változtatja meg azonnal a közzétett adatok teljes mennyiségét, lehetővé teszi az OPRA számára, hogy lényegesen gyorsabban terjessze az adatokat. Ez az átállás döntő fontosságú a dinamikus opciós piac igényeinek kielégítéséhez.

Az OPRA kiemelkedik az egyik legterjedelmesebb hírcsatornából: 150.4 harmadik negyedévében egyetlen nap alatt 3 milliárd üzenet érkezik, és a kapacitásigénye 2023 milliárd üzenet egyetlen nap alatt. Minden egyes üzenet rögzítése kritikus fontosságú a tranzakciós költségelemzés, a piaci likviditás figyelése, a kereskedési stratégia értékelése és a piackutatás szempontjából.

Az adatokról

LSEG Tick History – PCAP egy felhő alapú adattár, amely meghaladja a 30 PB-t, és rendkívül jó minőségű globális piaci adatokat tárol. Ezeket az adatokat aprólékosan rögzítik közvetlenül az adatcsere-adatközpontokban, redundáns rögzítési folyamatok alkalmazásával, amelyek stratégiailag elhelyezkednek a világ fő elsődleges és tartalék adatközpontjaiban. Az LSEG rögzítési technológiája veszteségmentes adatrögzítést biztosít, és GPS-időforrást használ a nanoszekundumos időbélyeg pontosságához. Ezenkívül kifinomult adatarbitrázs technikákat alkalmaznak az adathiányok zökkenőmentes kitöltésére. A rögzítést követően az adatok aprólékos feldolgozáson és döntésen esnek át, majd a parketta formátumba normalizálódnak. Az LSEG Real Time Ultra Direct (RTUD) takarmánykezelők.

A normalizálási folyamat, amely az adatok elemzésre való előkészítésének szerves részét képezi, akár 6 TB tömörített Parquet fájlt generál naponta. Az adatok hatalmas mennyisége az OPRA átfogó jellegének tudható be, amely több tőzsdére is kiterjed, és számos opciós szerződést tartalmaz, amelyeket különböző tulajdonságok jellemeznek. A megnövekedett piaci volatilitás és az opciós tőzsdék árjegyzői tevékenysége tovább járul hozzá az OPRA-n közzétett adatok mennyiségéhez.

A Tick History – PCAP attribútumai lehetővé teszik a cégek számára, hogy különféle elemzéseket végezzenek, beleértve a következőket:

  • Kereskedés előtti elemzés – Értékelje a lehetséges kereskedelmi hatásokat, és fedezze fel a különböző végrehajtási stratégiákat a korábbi adatok alapján
  • Kereskedés utáni értékelés – Mérje meg a tényleges végrehajtási költségeket a referenciaértékekkel összehasonlítva a végrehajtási stratégiák teljesítményének felmérése érdekében
  • optimalizált végrehajtás – A végrehajtási stratégiák finomhangolása a múltbeli piaci minták alapján a piaci hatás minimalizálása és az általános kereskedési költségek csökkentése érdekében
  • Kockázat kezelés – A csúszási minták azonosítása, a kiugró értékek azonosítása és a kereskedési tevékenységekkel kapcsolatos kockázatok proaktív kezelése
  • Teljesítmény-hozzárendelés – A portfólió teljesítményének elemzésekor válassza el a kereskedési döntések hatását a befektetési döntésektől

Az LSEG Tick History – PCAP adatkészlet itt érhető el AWS adatcsere és a címen érhető el AWS piactér. A AWS adatcsere az Amazon S3-hoz, közvetlenül az LSEG-ből érheti el a PCAP-adatokat Amazon egyszerű tárolási szolgáltatás (Amazon S3). Ez a megközelítés leegyszerűsíti az adatkezelést és -tárolást, azonnali hozzáférést biztosítva az ügyfeleknek a kiváló minőségű PCAP-hoz vagy normalizált adatokhoz, könnyen használható, integrálható és jelentős adattárolási megtakarítás.

Athena az Apache Spark számára

Az elemző törekvésekhez Athena az Apache Spark számára egyszerűsített notebook élményt kínál, amely az Athena konzolon vagy az Athena API-kon keresztül érhető el, lehetővé téve az interaktív Apache Spark alkalmazások létrehozását. Az optimalizált Spark futási idővel az Athena segíti a petabájtnyi adat elemzését azáltal, hogy dinamikusan skálázza a Spark-motorok számát egy másodpercnél kevesebbre. Ezenkívül a gyakori Python-könyvtárak, például a pandák és a NumPy zökkenőmentesen integrálódnak, lehetővé téve bonyolult alkalmazáslogika létrehozását. A rugalmasság kiterjed a notebookokban használható egyedi könyvtárak importálására is. Az Athena for Spark a legtöbb nyílt adatformátumhoz illeszkedik, és zökkenőmentesen integrálódik a AWS ragasztó Adatkatalógus.

adatbázisba

Ehhez az elemzéshez a 17. május 2023-i LSEG Tick History – PCAP OPRA adatkészletet használtuk. Ez az adatkészlet a következő összetevőket tartalmazza:

  • Legjobb ajánlat és ajánlat (BBO) – Jelenti az adott tőzsdén a legmagasabb ajánlatot és a legalacsonyabb ajánlatot egy értékpapírra
  • Országos legjobb ajánlat és ajánlat (NBBO) – Jelenti a legmagasabb ajánlatot és a legalacsonyabb értékpapírt az összes tőzsdén
  • mesterségek – Rögzíti a befejezett kereskedéseket az összes tőzsdén

Az adatkészlet a következő adatmennyiségeket tartalmazza:

  • mesterségek – 160 MB körülbelül 60 tömörített Parquet fájl között elosztva
  • BBO – 2.4 TB körülbelül 300 tömörített Parquet fájl között elosztva
  • NBBO – 2.8 TB körülbelül 200 tömörített Parquet fájl között elosztva

Elemzés áttekintése

Az OPRA Tick History adatainak elemzése a Tranzakciós Költségelemzéshez (TCA) magában foglalja a piaci jegyzések és kereskedések áttekintését egy adott kereskedelmi esemény körül. A tanulmány részeként a következő mutatókat használjuk:

  • Idézett spread (QS) – A BBO-kérés és a BBO-ajánlat különbségeként számítva
  • Hatékony spread (ES) – A kereskedési ár és a BBO felezőpontja közötti különbségként számítva (BBO licit + (BBO ask – BBO bid)/2)
  • Effektív/idézett árrés (EQF) – Kiszámítva (ES / QS) * 100

Ezeket a felárakat a kereskedés előtt és négy időközönként a kereskedés után számítjuk ki (közvetlenül a kereskedés után, 1 másodperccel, 10 másodperccel és 60 másodperccel a kereskedés után).

Konfigurálja az Athena-t az Apache Sparkhoz

Az Athena Apache Sparkhoz való konfigurálásához hajtsa végre a következő lépéseket:

  1. Az Athena konzolon, alatt Első lépésekválassza Elemezze adatait PySpark és Spark SQL használatával.
  2. Ha először használja az Athena Sparkot, válassza a lehetőséget Munkacsoport létrehozása.
  3. A Munkacsoport neve¸ adjon meg egy nevet a munkacsoportnak, például tca-analysis.
  4. A Analytics motor válasszon Apache Spark.
  5. A További konfigurációk részben választhat Alapértelmezések használata vagy egyéni AWS Identity and Access Management (IAM) szerepkör és Amazon S3 hely a számítási eredményekhez.
  6. A pop-art design, négy időzóna kijelzése egyszerre és méretének arányai azok az érvek, amelyek a NeXtime Time Zones-t kiváló választássá teszik. Válassza a Munkacsoport létrehozása.
  7. A munkacsoport létrehozása után navigáljon a notebookok lapot és válasszon Jegyzetfüzet létrehozása.
  8. Adja meg a jegyzetfüzet nevét, például tca-analysis-with-tick-history.
  9. A pop-art design, négy időzóna kijelzése egyszerre és méretének arányai azok az érvek, amelyek a NeXtime Time Zones-t kiváló választássá teszik. Válassza a Teremt jegyzetfüzet létrehozásához.

Indítsa el a notebookját

Ha már létrehozott egy Spark-munkacsoportot, válassza a lehetőséget Indítsa el a notebook szerkesztőt alatt Első lépések.


A jegyzetfüzet létrehozása után a rendszer átirányítja az interaktív jegyzetfüzetszerkesztőhöz.


Most hozzáadhatjuk és futtathatjuk a következő kódot a notebookunkhoz.

Készítsen elemzést

Az elemzés elkészítéséhez hajtsa végre a következő lépéseket:

  • Gyakori könyvtárak importálása:
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go

  • Hozza létre adatkereteinket BBO, NBBO és kereskedésekhez:
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")

  • Most azonosíthatunk egy kereskedést, amelyet a tranzakciós költségek elemzéséhez használunk:
filtered_trades = spark.sql("select Product, Price,Quantity, ReceiptTimestamp, MarketParticipant from trades")

A következő kimenetet kapjuk:

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

A kiemelt kereskedelmi információkat használjuk a továbbiakban a kereskedelmi termékre (tp), a kereskedési árra (tpr) és a kereskedési időre (tt).

  • Itt számos segítő függvényt hozunk létre elemzésünkhöz
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

  • A következő függvényben létrehozzuk azt az adatkészletet, amely tartalmazza az összes kereskedés előtti és utáni jegyzést. Az Athena Spark automatikusan meghatározza, hogy hány DPU-t indítson el az adatkészletünk feldolgozásához.
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

  • Most hívjuk meg a TCA elemzési függvényt a kiválasztott kereskedésünkből származó információkkal:
tp = "QQQ 230518C00329000"
tpr = 1.16
tt = 1684338579104713924
c = get_tca_analysis_via_df_single_query(tp, tpr, tt)

Vizualizálja az elemzési eredményeket

Most hozzuk létre a vizualizációhoz használt adatkereteket. Minden adatkeret idézőjeleket tartalmaz az egyes adatfolyamokhoz tartozó öt időintervallum egyikéhez (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)]

A következő szakaszokban példakóddal szolgálunk különböző vizualizációk létrehozásához.

A kereskedés előtt ábrázolja a QS-t és az NBBO-t

Használja a következő kódot a jegyzett spread és az NBBO ábrázolásához a kereskedés előtt:

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

Minden piachoz ábrázolja a QS-t és a kereskedés után az NBBO-t

Használja a következő kódot az egyes piacok és NBBO jegyzett felárak ábrázolásához közvetlenül a kereskedés után:

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

Ábrázolja a QS-t minden időintervallumhoz és minden piachoz a BBO-hoz

Használja a következő kódot a jegyzett felárak ábrázolásához minden egyes időintervallumhoz és a BBO piacához:

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

Ábrázolja az ES-t minden időintervallumhoz és piachoz a BBO-hoz

Használja a következő kódot az egyes időintervallumokra és a BBO piacára vonatkozó effektív spread ábrázolásához:

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

Ábrázolja az EQF-et minden időintervallumhoz és piachoz a BBO-hoz

Használja a következő kódot az effektív/jegyzett felárak ábrázolásához minden egyes időintervallumhoz és a BBO piacához:

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 számítási teljesítmény

Kódblokk futtatásakor az Athena Spark automatikusan meghatározza, hogy hány DPU-ra van szüksége a számítás befejezéséhez. Az utolsó kódblokkban, ahol a tca_analysis függvényt, valójában a Sparkot utasítjuk az adatok feldolgozására, majd a kapott Spark-adatkereteket Pandas-adatkeretekké alakítjuk. Ez az elemzés legintenzívebb feldolgozási részét képezi, és amikor az Athena Spark futtatja ezt a blokkot, megmutatja a folyamatjelző sávot, az eltelt időt és azt, hogy hány DPU dolgoz fel jelenleg adatokat. Például a következő számításban az Athena Spark 18 DPU-t használ.

Az Athena Spark notebook konfigurálásakor beállíthatja az általa használható DPU-k maximális számát. Az alapértelmezett 20 DPU, de ezt a számítást 10, 20 és 40 DPU-val teszteltük, hogy bemutassuk, hogyan skálázódik automatikusan az Athena Spark az elemzés futtatásához. Megfigyeltük, hogy az Athena Spark lineárisan skálázódik: 15 perc és 21 másodperc, amikor a notebook maximum 10 DPU-val volt konfigurálva, 8 perc és 23 másodperc, ha a notebook 20 DPU-val volt konfigurálva, és 4 perc 44 másodperc, amikor a notebook 40 DPU-val konfigurálva. Mivel az Athena Spark a DPU-használat alapján számít, másodpercenkénti részletességgel, ezeknek a számításoknak a költsége hasonló, de ha magasabb maximális DPU-értéket állít be, az Athena Spark sokkal gyorsabban tudja visszaadni az elemzés eredményét. Az Athena Spark árakkal kapcsolatos további részletekért kattintson itt.

Következtetés

Ebben a bejegyzésben bemutattuk, hogyan használhatja fel az LSEG Tick History-PCAP-jából származó nagy pontosságú OPRA-adatokat a tranzakciós költségek elemzéséhez az Athena Spark segítségével. Az OPRA adatok időben történő elérhetősége, kiegészítve az AWS Data Exchange for Amazon S3 akadálymentesítési újításaival, stratégiailag lecsökkenti az elemzéshez szükséges időt azon cégek számára, amelyek a kritikus kereskedési döntésekhez hasznos betekintést szeretnének készíteni. Az OPRA naponta körülbelül 7 TB normalizált parketta adatot generál, és az infrastruktúra kezelése az OPRA adatokon alapuló elemzések biztosítására kihívást jelent.

Az Athena méretezhetősége a Tick History – PCAP for OPRA adatok nagy léptékű adatfeldolgozásának kezelésében – lenyűgöző választássá teszi az AWS-ben gyors és méretezhető elemzési megoldásokat kereső szervezetek számára. Ez a bejegyzés bemutatja az AWS ökoszisztéma és a Tick History-PCAP adatai közötti zökkenőmentes interakciót, és azt, hogy a pénzintézetek hogyan tudják kihasználni ezt a szinergiát az adatvezérelt döntéshozatal érdekében a kritikus kereskedési és befektetési stratégiákhoz.

A szerzőkről

Pramod Nayak az LSEG Low Latency Group termékmenedzsment igazgatója. A Pramod több mint 10 éves tapasztalattal rendelkezik a pénzügyi technológiai iparágban, elsősorban a szoftverfejlesztésre, az elemzésekre és az adatkezelésre összpontosít. Pramod korábbi szoftvermérnök, és szenvedélyesen foglalkozik a piaci adatokkal és a mennyiségi kereskedéssel.

LakshmiKanth Mannem az LSEG Low Latency Group termékmenedzsere. Az alacsony késleltetésű piaci adatipar adat- és platformtermékeire összpontosít. A LakshmiKanth segít az ügyfeleknek a legoptimálisabb megoldások kidolgozásában piaci adatigényeikhez.

Vivek Aggarwal vezető adatmérnök az LSEG alacsony késleltetésű csoportjában. A Vivek adatfolyamok fejlesztésén és karbantartásán dolgozik a rögzített piaci adatfolyamok és referencia adatfolyamok feldolgozásához és szállításához.

Alket Memushaj az AWS pénzügyi szolgáltatások piacfejlesztési csapatának vezető építésze. Az Alket felelős a műszaki stratégiáért, partnerekkel és ügyfelekkel együttműködve, hogy még a legigényesebb tőkepiaci munkaterheléseket is telepítse az AWS felhőbe.

Időbélyeg:

Még több AWS Big Data