Menguasai dinamika pasar: Mengubah analisis biaya transaksi dengan Tick History yang sangat presisi – PCAP dan Amazon Athena untuk Apache Spark | Layanan Web Amazon

Menguasai dinamika pasar: Mengubah analisis biaya transaksi dengan Tick History yang sangat presisi – PCAP dan Amazon Athena untuk Apache Spark | Layanan Web Amazon

Stempel Waktu: 31 Januari 2024 12:20
Node Sumber: 3091357

Postingan ini ditulis bersama Pramod Nayak, LakshmiKanth Mannem, dan Vivek Aggarwal dari Grup Latensi Rendah LSEG.

Analisis biaya transaksi (TCA) banyak digunakan oleh para pedagang, manajer portofolio, dan broker untuk analisis pra-perdagangan dan pasca-perdagangan, dan membantu mereka mengukur dan mengoptimalkan biaya transaksi dan efektivitas strategi perdagangan mereka. Dalam posting ini, kami menganalisis opsi bid-ask spread dari Riwayat Centang LSEG – PCAP kumpulan data menggunakan Amazon Athena untuk Apache Spark. Kami menunjukkan kepada Anda cara mengakses data, menentukan fungsi kustom untuk diterapkan pada data, mengkueri dan memfilter kumpulan data, dan memvisualisasikan hasil analisis, semuanya tanpa harus khawatir menyiapkan infrastruktur atau mengonfigurasi Spark, bahkan untuk kumpulan data besar.

Latar Belakang

Otoritas Pelaporan Harga Opsi (OPRA) berfungsi sebagai pemroses informasi sekuritas yang penting, mengumpulkan, mengkonsolidasikan, dan menyebarkan laporan penjualan terakhir, penawaran harga, dan informasi terkait untuk Opsi AS. Dengan 18 bursa Opsi AS yang aktif dan lebih dari 1.5 juta kontrak yang memenuhi syarat, OPRA memainkan peran penting dalam menyediakan data pasar yang komprehensif.

Pada tanggal 5 Februari 2024, Securities Industry Automation Corporation (SIAC) akan meningkatkan feed OPRA dari 48 menjadi 96 saluran multicast. Peningkatan ini bertujuan untuk mengoptimalkan distribusi simbol dan pemanfaatan kapasitas jalur sebagai respons terhadap meningkatnya aktivitas perdagangan dan volatilitas di pasar opsi AS. SIAC telah merekomendasikan agar perusahaan bersiap menghadapi kecepatan data puncak hingga 37.3 GBits per detik.

Meskipun peningkatan ini tidak serta merta mengubah total volume data yang dipublikasikan, hal ini memungkinkan OPRA untuk menyebarkan data dengan kecepatan yang jauh lebih cepat. Transisi ini sangat penting untuk memenuhi tuntutan pasar opsi yang dinamis.

OPRA menonjol sebagai salah satu feed yang paling banyak jumlahnya, dengan puncak 150.4 miliar pesan dalam satu hari pada Q3 2023 dan kebutuhan kapasitas headroom sebesar 400 miliar pesan dalam satu hari. Menangkap setiap pesan sangat penting untuk analisis biaya transaksi, pemantauan likuiditas pasar, evaluasi strategi perdagangan, dan riset pasar.

Tentang data

Riwayat Centang LSEG – PCAP adalah repositori berbasis cloud, melebihi 30 PB, menampung data pasar global berkualitas sangat tinggi. Data ini ditangkap dengan cermat langsung di dalam pusat data pertukaran, menggunakan proses pengambilan redundan yang ditempatkan secara strategis di pusat data pertukaran utama dan cadangan di seluruh dunia. Teknologi penangkapan LSEG memastikan pengambilan data tanpa kehilangan dan menggunakan sumber waktu GPS untuk ketepatan cap waktu nanodetik. Selain itu, teknik arbitrase data yang canggih digunakan untuk mengisi kesenjangan data dengan lancar. Setelah ditangkap, data menjalani pemrosesan dan arbitrase yang cermat, dan kemudian dinormalisasi ke dalam format Parket menggunakan Ultra Langsung Waktu Nyata LSEG (RTUD) penangan pakan.

Proses normalisasi, yang merupakan bagian integral dalam mempersiapkan data untuk analisis, menghasilkan hingga 6 TB file Parket terkompresi per hari. Volume data yang sangat besar disebabkan oleh sifat OPRA yang mencakup banyak pertukaran, dan menampilkan banyak kontrak opsi yang ditandai dengan beragam atribut. Meningkatnya volatilitas pasar dan aktivitas pembuatan pasar di bursa opsi semakin berkontribusi terhadap volume data yang dipublikasikan di OPRA.

Atribut Tick History – PCAP memungkinkan perusahaan melakukan berbagai analisis, termasuk yang berikut:

  • Analisis pra-perdagangan – Mengevaluasi potensi dampak perdagangan dan mengeksplorasi berbagai strategi eksekusi berdasarkan data historis
  • Evaluasi pasca-perdagangan – Mengukur biaya eksekusi aktual terhadap tolok ukur untuk menilai kinerja strategi eksekusi
  • Dioptimalkan eksekusi – Menyempurnakan strategi eksekusi berdasarkan pola pasar historis untuk meminimalkan dampak pasar dan mengurangi biaya perdagangan secara keseluruhan
  • Manajemen risiko – Identifikasi pola slippage, identifikasi outlier, dan kelola risiko yang terkait dengan aktivitas perdagangan secara proaktif
  • Atribusi kinerja – Pisahkan dampak keputusan perdagangan dari keputusan investasi saat menganalisis kinerja portofolio

Riwayat Kutu LSEG – kumpulan data PCAP tersedia di Pertukaran Data AWS dan dapat diakses di Pasar AWS. Dengan AWS Pertukaran Data untuk Amazon S3, Anda dapat mengakses data PCAP langsung dari LSEG Layanan Penyimpanan Sederhana Amazon (Amazon S3), menghilangkan kebutuhan bagi perusahaan untuk menyimpan salinan data mereka sendiri. Pendekatan ini menyederhanakan pengelolaan dan penyimpanan data, memberikan klien akses langsung ke PCAP berkualitas tinggi atau data yang dinormalisasi dengan kemudahan penggunaan, integrasi, dan penghematan penyimpanan data yang besar.

Athena untuk Apache Spark

Untuk upaya analitis, Athena untuk Apache Spark menawarkan pengalaman notebook sederhana yang dapat diakses melalui konsol Athena atau API Athena, memungkinkan Anda membuat aplikasi Apache Spark interaktif. Dengan runtime Spark yang dioptimalkan, Athena membantu analisis data berukuran petabyte dengan menskalakan jumlah mesin Spark secara dinamis kurang dari satu detik. Selain itu, pustaka Python umum seperti pandas dan NumPy terintegrasi dengan mulus, memungkinkan pembuatan logika aplikasi yang rumit. Fleksibilitasnya mencakup impor pustaka kustom untuk digunakan di buku catatan. Athena for Spark mengakomodasi sebagian besar format data terbuka dan terintegrasi secara mulus dengan Lem AWS Katalog Data.

Dataset

Untuk analisis ini, kami menggunakan kumpulan data LSEG Tick History – PCAP OPRA mulai 17 Mei 2023. Kumpulan data ini terdiri dari komponen-komponen berikut:

  • Tawaran dan penawaran terbaik (BBO) – Melaporkan tawaran tertinggi dan permintaan terendah untuk sekuritas di bursa tertentu
  • Penawaran dan Penawaran Terbaik Nasional (NBBO) – Melaporkan tawaran tertinggi dan permintaan keamanan terendah di semua bursa
  • Trades – Catatan menyelesaikan perdagangan di semua bursa

Himpunan data melibatkan volume data berikut:

  • Trades – 160 MB didistribusikan ke sekitar 60 file Parket terkompresi
  • BBO – 2.4 TB didistribusikan ke sekitar 300 file Parket terkompresi
  • NBCO – 2.8 TB didistribusikan ke sekitar 200 file Parket terkompresi

Ikhtisar analisis

Menganalisis data Riwayat Tick OPRA untuk Analisis Biaya Transaksi (TCA) melibatkan penelitian kuotasi pasar dan perdagangan seputar peristiwa perdagangan tertentu. Kami menggunakan metrik berikut sebagai bagian dari penelitian ini:

  • Spread yang dikutip (QS) – Dihitung sebagai selisih antara permintaan BBO dan tawaran BBO
  • Penyebaran efektif (ES) – Dihitung sebagai selisih antara harga perdagangan dan titik tengah BBO (BBO bid + (BBO ask – BBO bid)/2)
  • Spread efektif/dikutip (EQF) – Dihitung sebagai (ES / QS) * 100

Kami menghitung spread ini sebelum perdagangan dan juga pada empat interval setelah perdagangan (tepat setelahnya, 1 detik, 10 detik, dan 60 detik setelah perdagangan).

Konfigurasikan Athena untuk Apache Spark

Untuk mengonfigurasi Athena untuk Apache Spark, selesaikan langkah-langkah berikut:

  1. Di konsol Athena, di bawah Get started, pilih Analisis data Anda menggunakan PySpark dan Spark SQL.
  2. Jika ini pertama kalinya Anda menggunakan Athena Spark, pilih Buat grup kerja.
  3. Untuk Nama grup kerja¸ masukkan nama untuk kelompok kerja, misalnya tca-analysis.
  4. Dalam majalah Mesin analitik bagian, pilih Apache Spark.
  5. Dalam majalah Konfigurasi tambahan bagian, Anda dapat memilih Gunakan default atau memberikan kebiasaan Identitas AWS dan Manajemen Akses (IAM) role dan lokasi Amazon S3 untuk hasil perhitungan.
  6. Pilih Buat grup kerja.
  7. Setelah Anda membuat grup kerja, navigasikan ke notebook tab dan pilih Buat buku catatan.
  8. Masukkan nama untuk buku catatan Anda, misalnya tca-analysis-with-tick-history.
  9. Pilih membuat untuk membuat buku catatan Anda.

Luncurkan buku catatan Anda

Jika Anda sudah membuat grup kerja Spark, pilih Luncurkan editor buku catatan bawah Get started.


Setelah buku catatan Anda dibuat, Anda akan diarahkan ke editor buku catatan interaktif.


Sekarang kita dapat menambahkan dan menjalankan kode berikut ke notebook kita.

Buat analisis

Selesaikan langkah-langkah berikut untuk membuat analisis:

  • Impor perpustakaan umum:
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go

  • Buat bingkai data kami untuk BBO, NBBO, dan perdagangan:
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")

  • Sekarang kita dapat mengidentifikasi perdagangan yang akan digunakan untuk analisis biaya transaksi:
filtered_trades = spark.sql("select Product, Price,Quantity, ReceiptTimestamp, MarketParticipant from trades")

Kami mendapatkan output berikut:

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

Kami menggunakan informasi perdagangan yang disorot ke depan untuk produk perdagangan (tp), harga perdagangan (tpr), dan waktu perdagangan (tt).

  • Di sini kami membuat sejumlah fungsi pembantu untuk analisis kami
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

  • Dalam fungsi berikut, kami membuat kumpulan data yang berisi semua kutipan sebelum dan sesudah perdagangan. Athena Spark secara otomatis menentukan berapa banyak DPU yang akan diluncurkan untuk memproses kumpulan data kami.
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

  • Sekarang mari kita panggil fungsi analisis TCA dengan informasi dari perdagangan pilihan kita:
tp = "QQQ 230518C00329000"
tpr = 1.16
tt = 1684338579104713924
c = get_tca_analysis_via_df_single_query(tp, tpr, tt)

Visualisasikan hasil analisis

Sekarang mari kita buat bingkai data yang kita gunakan untuk visualisasi kita. Setiap bingkai data berisi kutipan untuk salah satu dari lima interval waktu untuk setiap umpan data (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)]

Di bagian berikut, kami memberikan contoh kode untuk membuat visualisasi yang berbeda.

Plot QS dan NBBO sebelum perdagangan

Gunakan kode berikut untuk memplot spread dan NBBO yang dikutip sebelum perdagangan:

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

Plot QS untuk setiap pasar dan NBBO setelah perdagangan

Gunakan kode berikut untuk memplot spread yang dikutip untuk setiap pasar dan NBBO segera setelah perdagangan:

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

Plot QS untuk setiap interval waktu dan setiap pasar untuk BBO

Gunakan kode berikut untuk memplot spread yang dikutip untuk setiap interval waktu dan setiap pasar untuk BBO:

fig = go.Figure(data=[
    go.Bar(name="before trade", x=bbo_bef.MarketParticipant.unique(), y=bbo_bef['QS']),
    go.Bar(name="0s after trade", x=bbo_aft_0.MarketParticipant.unique(), y=bbo_aft_0['QS']),
    go.Bar(name="1s after trade", x=bbo_aft_1.MarketParticipant.unique(), y=bbo_aft_1['QS']),
    go.Bar(name="10s after trade", x=bbo_aft_10.MarketParticipant.unique(), y=bbo_aft_10['QS']),
    go.Bar(name="60s after trade", x=bbo_aft_60.MarketParticipant.unique(), y=bbo_aft_60['QS'])])
fig.update_layout(barmode='group',title="BBO Quoted Spread Per Market/TimeFrame",
    xaxis={'title':'Market'},
    yaxis={'title':'Quoted Spread'})
%plotly fig

Plot ES untuk setiap interval waktu dan pasar untuk BBO

Gunakan kode berikut untuk memplot spread efektif untuk setiap interval waktu dan pasar BBO:

fig = go.Figure(data=[
    go.Bar(name="before trade", x=bbo_bef.MarketParticipant.unique(), y=bbo_bef['ES']),
    go.Bar(name="0s after trade", x=bbo_aft_0.MarketParticipant.unique(), y=bbo_aft_0['ES']),
    go.Bar(name="1s after trade", x=bbo_aft_1.MarketParticipant.unique(), y=bbo_aft_1['ES']),
    go.Bar(name="10s after trade", x=bbo_aft_10.MarketParticipant.unique(), y=bbo_aft_10['ES']),
    go.Bar(name="60s after trade", x=bbo_aft_60.MarketParticipant.unique(), y=bbo_aft_60['ES'])])
fig.update_layout(barmode='group',title="BBO Effective Spread Per Market/TimeFrame",
    xaxis={'title':'Market'}, 
    yaxis={'title':'Effective Spread'})
%plotly fig

Plot EQF untuk setiap interval waktu dan pasar untuk BBO

Gunakan kode berikut untuk memplot spread efektif/kuotasi untuk setiap interval waktu dan pasar untuk BBO:

fig = go.Figure(data=[
    go.Bar(name="before trade", x=bbo_bef.MarketParticipant.unique(), y=bbo_bef['EQF']),
    go.Bar(name="0s after trade", x=bbo_aft_0.MarketParticipant.unique(), y=bbo_aft_0['EQF']),
    go.Bar(name="1s after trade", x=bbo_aft_1.MarketParticipant.unique(), y=bbo_aft_1['EQF']),
    go.Bar(name="10s after trade", x=bbo_aft_10.MarketParticipant.unique(), y=bbo_aft_10['EQF']),
    go.Bar(name="60s after trade", x=bbo_aft_60.MarketParticipant.unique(), y=bbo_aft_60['EQF'])])
fig.update_layout(barmode='group',title="BBO Effective/Quoted Spread Per Market/TimeFrame",
    xaxis={'title':'Market'}, 
    yaxis={'title':'Effective/Quoted Spread'})
%plotly fig

Kinerja perhitungan Athena Spark

Saat Anda menjalankan blok kode, Athena Spark secara otomatis menentukan berapa banyak DPU yang diperlukan untuk menyelesaikan penghitungan. Di blok kode terakhir, tempat kita memanggil tca_analysis fungsi, kami sebenarnya menginstruksikan Spark untuk memproses data, dan kami kemudian mengubah kerangka data Spark yang dihasilkan menjadi kerangka data Pandas. Ini merupakan bagian pemrosesan analisis yang paling intensif, dan ketika Athena Spark menjalankan blok ini, blok ini menunjukkan bilah kemajuan, waktu yang berlalu, dan berapa banyak DPU yang memproses data saat ini. Misalnya pada perhitungan berikut, Athena Spark menggunakan 18 DPU.

Saat mengonfigurasi notebook Athena Spark, Anda memiliki opsi untuk mengatur jumlah maksimum DPU yang dapat digunakan. Defaultnya adalah 20 DPU, namun kami menguji perhitungan ini dengan 10, 20, dan 40 DPU untuk menunjukkan bagaimana Athena Spark secara otomatis menskalakan untuk menjalankan analisis kami. Kami mengamati bahwa Athena Spark menskalakan secara linier, memerlukan waktu 15 menit dan 21 detik saat notebook dikonfigurasi dengan maksimum 10 DPU, 8 menit dan 23 detik saat notebook dikonfigurasi dengan 20 DPU, dan 4 menit dan 44 detik saat notebook dikonfigurasi. dikonfigurasi dengan 40 DPU. Karena Athena Spark mengenakan biaya berdasarkan penggunaan DPU, dengan rincian per detik, biaya penghitungan ini serupa, namun jika Anda menetapkan nilai DPU maksimum yang lebih tinggi, Athena Spark dapat mengembalikan hasil analisis lebih cepat. Untuk detail lebih lanjut mengenai harga Athena Spark silakan klik di sini.

Kesimpulan

Dalam postingan ini, kami mendemonstrasikan bagaimana Anda dapat menggunakan data OPRA dengan fidelitas tinggi dari Tick History-PCAP LSEG untuk melakukan analisis biaya transaksi menggunakan Athena Spark. Ketersediaan data OPRA secara tepat waktu, dilengkapi dengan inovasi aksesibilitas AWS Data Exchange untuk Amazon S3, secara strategis mengurangi waktu analisis bagi perusahaan yang ingin menciptakan wawasan yang dapat ditindaklanjuti untuk keputusan perdagangan penting. OPRA menghasilkan sekitar 7 TB data Parket yang dinormalisasi setiap hari, dan mengelola infrastruktur untuk menyediakan analisis berdasarkan data OPRA merupakan suatu tantangan.

Skalabilitas Athena dalam menangani pemrosesan data berskala besar untuk Tick History – PCAP untuk data OPRA menjadikannya pilihan menarik bagi organisasi yang mencari solusi analitik yang cepat dan terukur di AWS. Postingan ini menunjukkan interaksi yang mulus antara ekosistem AWS dan data Tick History-PCAP dan bagaimana lembaga keuangan dapat memanfaatkan sinergi ini untuk mendorong pengambilan keputusan berbasis data untuk strategi perdagangan dan investasi penting.

Tentang Penulis

Pramod Nayak adalah Direktur Manajemen Produk Grup Latensi Rendah di LSEG. Pramod memiliki pengalaman lebih dari 10 tahun di industri teknologi keuangan, dengan fokus pada pengembangan perangkat lunak, analitik, dan manajemen data. Pramod adalah mantan insinyur perangkat lunak dan sangat tertarik dengan data pasar dan perdagangan kuantitatif.

LakshmiKanth Mannem adalah Manajer Produk di Grup Latensi Rendah LSEG. Dia berfokus pada produk data dan platform untuk industri data pasar latensi rendah. LakshmiKanth membantu pelanggan membangun solusi paling optimal untuk kebutuhan data pasar mereka.

Vivek Aggarwal adalah Insinyur Data Senior di Grup Latensi Rendah LSEG. Vivek berupaya mengembangkan dan memelihara jalur data untuk pemrosesan dan pengiriman umpan data pasar yang ditangkap dan umpan data referensi.

Alket Memushaj adalah Arsitek Utama di tim Pengembangan Pasar Jasa Keuangan di AWS. Alket bertanggung jawab atas strategi teknis, bekerja sama dengan mitra dan pelanggan untuk menerapkan beban kerja pasar modal yang paling menuntut sekalipun ke AWS Cloud.

Stempel Waktu:

Lebih dari Data Besar AWS