Nắm vững động lực thị trường: Chuyển đổi phân tích chi phí giao dịch với Lịch sử đánh dấu cực kỳ chính xác – PCAP và Amazon Athena cho Apache Spark | Dịch vụ web của Amazon

Nắm vững động lực thị trường: Chuyển đổi phân tích chi phí giao dịch với Lịch sử đánh dấu cực kỳ chính xác – PCAP và Amazon Athena cho Apache Spark | Dịch vụ web của Amazon

Dấu thời gian: 31:2024 chiều ngày 12 tháng 20 năm XNUMX
Nút nguồn: 3091357

Bài đăng này được viết chung với Pramod Nayak, LakshmiKanth Mannem và Vivek Aggarwal từ Nhóm có độ trễ thấp của LSEG.

Phân tích chi phí giao dịch (TCA) được các nhà giao dịch, nhà quản lý danh mục đầu tư và nhà môi giới sử dụng rộng rãi để phân tích trước và sau giao dịch, đồng thời giúp họ đo lường và tối ưu hóa chi phí giao dịch cũng như hiệu quả của chiến lược giao dịch. Trong bài đăng này, chúng tôi phân tích chênh lệch giá chào bán quyền chọn từ Lịch sử đánh dấu LSEG – PCAP tập dữ liệu sử dụng Amazon Athena cho Apache Spark. Chúng tôi chỉ cho bạn cách truy cập dữ liệu, xác định các hàm tùy chỉnh để áp dụng trên dữ liệu, truy vấn và lọc tập dữ liệu cũng như trực quan hóa kết quả phân tích mà không phải lo lắng về việc thiết lập cơ sở hạ tầng hoặc định cấu hình Spark, ngay cả đối với các tập dữ liệu lớn.

Tiểu sử

Cơ quan báo cáo giá quyền chọn (OPRA) đóng vai trò là cơ quan xử lý thông tin chứng khoán quan trọng, thu thập, tổng hợp và phổ biến các báo cáo bán hàng cuối cùng, báo giá và thông tin thích hợp cho Quyền chọn Hoa Kỳ. Với 18 sàn giao dịch Quyền chọn Hoa Kỳ đang hoạt động và hơn 1.5 triệu hợp đồng đủ điều kiện, OPRA đóng vai trò then chốt trong việc cung cấp dữ liệu thị trường toàn diện.

Vào ngày 5 tháng 2024 năm 48, Tập đoàn Tự động hóa Công nghiệp Chứng khoán (SIAC) dự kiến ​​nâng cấp nguồn cấp dữ liệu OPRA từ 96 lên 37.3 kênh phát đa hướng. Cải tiến này nhằm mục đích tối ưu hóa việc phân phối biểu tượng và sử dụng công suất đường dây để đáp ứng với hoạt động giao dịch leo thang và biến động trên thị trường quyền chọn Hoa Kỳ. SIAC đã khuyến nghị các công ty nên chuẩn bị cho tốc độ dữ liệu cao nhất lên tới XNUMX GBits mỗi giây.

Mặc dù việc nâng cấp không làm thay đổi ngay lập tức tổng khối lượng dữ liệu được xuất bản nhưng nó cho phép OPRA phổ biến dữ liệu với tốc độ nhanh hơn đáng kể. Quá trình chuyển đổi này rất quan trọng để giải quyết nhu cầu của thị trường quyền chọn năng động.

OPRA nổi bật là một trong những nguồn cấp dữ liệu có số lượng lớn nhất, với mức cao nhất là 150.4 tỷ tin nhắn trong một ngày vào quý 3 năm 2023 và yêu cầu về dung lượng khoảng 400 tỷ tin nhắn trong một ngày. Nắm bắt từng thông điệp là rất quan trọng để phân tích chi phí giao dịch, giám sát thanh khoản thị trường, đánh giá chiến lược giao dịch và nghiên cứu thị trường.

Về dữ liệu

Lịch sử đánh dấu LSEG – PCAP là kho lưu trữ dựa trên đám mây, vượt quá 30 PB, chứa dữ liệu thị trường toàn cầu chất lượng cực cao. Dữ liệu này được thu thập một cách tỉ mỉ trực tiếp trong các trung tâm dữ liệu trao đổi, sử dụng các quy trình thu thập dự phòng được bố trí chiến lược tại các trung tâm dữ liệu trao đổi chính và dự phòng lớn trên toàn thế giới. Công nghệ chụp của LSEG đảm bảo thu thập dữ liệu không bị mất và sử dụng nguồn thời gian GPS để có độ chính xác về dấu thời gian ở nano giây. Ngoài ra, các kỹ thuật chênh lệch giá dữ liệu phức tạp được sử dụng để lấp đầy liền mạch mọi khoảng trống dữ liệu. Sau khi thu thập, dữ liệu trải qua quá trình xử lý và phân xử tỉ mỉ, sau đó được chuẩn hóa thành định dạng Parquet bằng cách sử dụng Thời gian thực siêu trực tiếp của LSEG (RTUD) trình xử lý nguồn cấp dữ liệu.

Quá trình chuẩn hóa, một phần không thể thiếu trong quá trình chuẩn bị dữ liệu để phân tích, tạo ra tối đa 6 TB tệp Parquet nén mỗi ngày. Khối lượng dữ liệu khổng lồ được cho là do tính chất bao trùm của OPRA, trải rộng trên nhiều sàn giao dịch và bao gồm nhiều hợp đồng quyền chọn được đặc trưng bởi các thuộc tính đa dạng. Biến động thị trường gia tăng và hoạt động tạo lập thị trường trên các sàn giao dịch quyền chọn góp phần làm tăng thêm khối lượng dữ liệu được công bố trên OPRA.

Các thuộc tính của Lịch sử đánh giá – PCAP cho phép các công ty tiến hành nhiều phân tích khác nhau, bao gồm:

  • Phân tích trước giao dịch – Đánh giá tác động thương mại tiềm năng và khám phá các chiến lược thực hiện khác nhau dựa trên dữ liệu lịch sử
  • Đánh giá sau giao dịch – Đo lường chi phí thực hiện thực tế so với tiêu chuẩn để đánh giá hiệu quả của các chiến lược thực hiện
  • Tối ưu hóa thực hiện – Tinh chỉnh các chiến lược thực hiện dựa trên mô hình thị trường lịch sử để giảm thiểu tác động của thị trường và giảm chi phí giao dịch tổng thể
  • Quản trị rủi ro – Xác định mô hình trượt giá, xác định các ngoại lệ và chủ động quản lý rủi ro liên quan đến hoạt động giao dịch
  • Phân bổ hiệu suất – Tách biệt tác động của quyết định giao dịch khỏi quyết định đầu tư khi phân tích hiệu quả danh mục đầu tư

Lịch sử đánh dấu LSEG – Bộ dữ liệu PCAP có sẵn ở Trao đổi dữ liệu AWS và có thể được truy cập trên Thị trường AWS. Với Trao đổi dữ liệu AWS cho Amazon S3, bạn có thể truy cập dữ liệu PCAP trực tiếp từ LSEG Dịch vụ lưu trữ đơn giản của Amazon (Amazon S3), loại bỏ nhu cầu các công ty lưu trữ bản sao dữ liệu của riêng họ. Cách tiếp cận này hợp lý hóa việc quản lý và lưu trữ dữ liệu, cung cấp cho khách hàng quyền truy cập ngay vào PCAP chất lượng cao hoặc dữ liệu được chuẩn hóa một cách dễ dàng sử dụng, tích hợp và tiết kiệm lưu trữ dữ liệu đáng kể.

Athena cho Apache Spark

Đối với những nỗ lực phân tích, Athena cho Apache Spark cung cấp trải nghiệm máy tính xách tay đơn giản hóa có thể truy cập được thông qua bảng điều khiển Athena hoặc API Athena, cho phép bạn xây dựng các ứng dụng Apache Spark tương tác. Với thời gian chạy Spark được tối ưu hóa, Athena giúp phân tích hàng petabyte dữ liệu bằng cách điều chỉnh linh hoạt số lượng động cơ Spark trong thời gian chưa đầy một giây. Hơn nữa, các thư viện Python phổ biến như pandas và NumPy được tích hợp liền mạch, cho phép tạo ra logic ứng dụng phức tạp. Tính linh hoạt còn mở rộng đến việc nhập các thư viện tùy chỉnh để sử dụng trong sổ ghi chép. Athena cho Spark hỗ trợ hầu hết các định dạng dữ liệu mở và được tích hợp liền mạch với Keo AWS Danh mục dữ liệu.

Bộ dữ liệu

Để thực hiện phân tích này, chúng tôi đã sử dụng tập dữ liệu Lịch sử đánh dấu LSEG – PCAP OPRA từ ngày 17 tháng 2023 năm XNUMX. Tập dữ liệu này bao gồm các thành phần sau:

  • Giá thầu và chào giá tốt nhất (BBO) – Báo cáo giá thầu cao nhất và yêu cầu bảo mật thấp nhất tại một sàn giao dịch nhất định
  • Giá thầu và ưu đãi tốt nhất quốc gia (NBBO) – Báo cáo giá thầu cao nhất và yêu cầu bảo mật thấp nhất trên tất cả các sàn giao dịch
  • Ngành nghề – Ghi lại các giao dịch đã hoàn thành trên tất cả các sàn giao dịch

Bộ dữ liệu bao gồm các khối dữ liệu sau:

  • Ngành nghề – 160 MB được phân phối trên khoảng 60 tệp Parquet nén
  • BBO – 2.4 TB được phân phối trên khoảng 300 tệp Parquet nén
  • NBBO – 2.8 TB được phân phối trên khoảng 200 tệp Parquet nén

Tổng quan về phân tích

Phân tích dữ liệu Lịch sử đánh dấu OPRA để Phân tích chi phí giao dịch (TCA) bao gồm việc xem xét kỹ lưỡng các báo giá thị trường và giao dịch xung quanh một sự kiện giao dịch cụ thể. Chúng tôi sử dụng các số liệu sau đây như một phần của nghiên cứu này:

  • Chênh lệch giá niêm yết (QS) – Được tính bằng chênh lệch giữa giá bán BBO và giá thầu BBO
  • Lan truyền hiệu quả (ES) – Được tính bằng chênh lệch giữa giá giao dịch và điểm giữa của BBO (BBO bid + (BBO Ask – BBO bid)/2)
  • Chênh lệch hiệu quả/báo giá (EQF) – Tính bằng (ES/QS)*100

Chúng tôi tính toán các mức chênh lệch này trước khi giao dịch và bổ sung vào bốn khoảng thời gian sau giao dịch (ngay sau, 1 giây, 10 giây và 60 giây sau giao dịch).

Định cấu hình Athena cho Apache Spark

Để định cấu hình Athena cho Apache Spark, hãy hoàn thành các bước sau:

  1. Trên bảng điều khiển Athena, bên dưới Bắt đầu, lựa chọn Phân tích dữ liệu của bạn bằng PySpark và Spark SQL.
  2. Nếu đây là lần đầu tiên bạn sử dụng Athena Spark, hãy chọn Tạo nhóm làm việc.
  3. Trong tên nhóm làm việc¸ nhập tên cho nhóm làm việc, chẳng hạn như tca-analysis.
  4. Trong tạp chí công cụ phân tích phần, chọn Apache Spark.
  5. Trong tạp chí Cấu hình bổ sung phần, bạn có thể chọn Mặc định sử dụng hoặc cung cấp một tùy chỉnh Quản lý truy cập và nhận dạng AWS (IAM) và vị trí Amazon S3 để có kết quả tính toán.
  6. Chọn Tạo nhóm làm việc.
  7. Sau khi bạn tạo nhóm làm việc, hãy điều hướng đến máy tính xách tay tab và chọn Tạo sổ ghi chép.
  8. Nhập tên cho sổ ghi chép của bạn, chẳng hạn như tca-analysis-with-tick-history.
  9. Chọn Tạo để tạo sổ ghi chép của bạn.

Khởi chạy sổ ghi chép của bạn

Nếu bạn đã tạo nhóm làm việc Spark, hãy chọn Khởi chạy trình chỉnh sửa sổ ghi chép Dưới Bắt đầu.


Sau khi sổ ghi chép của bạn được tạo, bạn sẽ được chuyển hướng đến trình chỉnh sửa sổ ghi chép tương tác.


Bây giờ chúng ta có thể thêm và chạy đoạn mã sau vào sổ ghi chép của mình.

Tạo phân tích

Hoàn thành các bước sau để tạo bản phân tích:

  • Nhập thư viện chung:
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go

  • Tạo khung dữ liệu của chúng tôi cho BBO, NBBO và giao dịch:
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")

  • Bây giờ chúng ta có thể xác định một giao dịch để sử dụng cho việc phân tích chi phí giao dịch:
filtered_trades = spark.sql("select Product, Price,Quantity, ReceiptTimestamp, MarketParticipant from trades")

Chúng tôi nhận được kết quả sau:

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

Chúng tôi sử dụng thông tin giao dịch được đánh dấu trong tương lai cho sản phẩm giao dịch (tp), giá giao dịch (tpr) và thời gian giao dịch (tt).

  • Ở đây chúng tôi tạo ra một số hàm trợ giúp để phân tích
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

  • Trong hàm sau, chúng tôi tạo tập dữ liệu chứa tất cả các báo giá trước và sau giao dịch. Athena Spark tự động xác định số lượng DPU sẽ khởi chạy để xử lý tập dữ liệu của chúng tôi.
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

  • Bây giờ hãy gọi hàm phân tích TCA với thông tin từ giao dịch đã chọn của chúng tôi:
tp = "QQQ 230518C00329000"
tpr = 1.16
tt = 1684338579104713924
c = get_tca_analysis_via_df_single_query(tp, tpr, tt)

Trực quan hóa kết quả phân tích

Bây giờ hãy tạo các khung dữ liệu mà chúng ta sử dụng để trực quan hóa. Mỗi khung dữ liệu chứa các trích dẫn cho một trong năm khoảng thời gian cho mỗi nguồn cấp dữ liệu (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)]

Trong các phần sau, chúng tôi cung cấp mã ví dụ để tạo các hình ảnh trực quan khác nhau.

Vẽ biểu đồ QS và NBBO trước khi giao dịch

Sử dụng đoạn mã sau để vẽ biểu đồ chênh lệch được trích dẫn và NBBO trước khi giao dịch:

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

Vẽ biểu đồ QS cho từng thị trường và NBBO sau giao dịch

Sử dụng đoạn mã sau để vẽ biểu đồ chênh lệch giá được báo giá cho từng thị trường và NBBO ngay sau giao dịch:

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

Vẽ biểu đồ QS cho từng khoảng thời gian và từng thị trường cho BBO

Sử dụng đoạn mã sau để vẽ biểu đồ mức chênh lệch được trích dẫn cho từng khoảng thời gian và từng thị trường cho 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

Vẽ ES cho từng khoảng thời gian và thị trường cho BBO

Sử dụng đoạn mã sau để vẽ biểu đồ mức chênh lệch hiệu quả cho từng khoảng thời gian và thị trường cho 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

Vẽ biểu đồ EQF cho từng khoảng thời gian và thị trường cho BBO

Sử dụng đoạn mã sau để vẽ biểu đồ mức chênh lệch hiệu quả/được báo giá cho từng khoảng thời gian và thị trường cho 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

Hiệu suất tính toán của Athena Spark

Khi bạn chạy một khối mã, Athena Spark sẽ tự động xác định số lượng DPU cần thiết để hoàn thành việc tính toán. Trong khối mã cuối cùng, nơi chúng tôi gọi tca_analysis chức năng, chúng tôi thực sự đang hướng dẫn Spark xử lý dữ liệu và sau đó chúng tôi chuyển đổi các khung dữ liệu Spark thu được thành các khung dữ liệu Pandas. Đây là phần xử lý chuyên sâu nhất của phân tích và khi Athena Spark chạy khối này, nó sẽ hiển thị thanh tiến trình, thời gian đã trôi qua và số lượng DPU hiện đang xử lý dữ liệu. Ví dụ: trong phép tính sau, Athena Spark đang sử dụng 18 DPU.

Khi định cấu hình máy tính xách tay Athena Spark, bạn có tùy chọn đặt số lượng DPU tối đa mà nó có thể sử dụng. Mặc định là 20 DPU, nhưng chúng tôi đã thử nghiệm tính toán này với 10, 20 và 40 DPU để chứng minh cách Athena Spark tự động điều chỉnh quy mô để chạy phân tích của chúng tôi. Chúng tôi quan sát thấy Athena Spark chia tỷ lệ tuyến tính, mất 15 phút 21 giây khi máy tính xách tay được cấu hình với tối đa 10 DPU, 8 phút 23 giây khi máy tính xách tay được cấu hình với 20 DPU và 4 phút 44 giây khi máy tính xách tay được cấu hình với 40 DPU. được cấu hình với XNUMX DPU. Vì Athena Spark tính phí dựa trên mức sử dụng DPU nên chi phí của những tính toán này là tương tự nhau, nhưng nếu bạn đặt giá trị DPU tối đa cao hơn, Athena Spark có thể trả về kết quả phân tích nhanh hơn nhiều. Để biết thêm chi tiết về giá Athena Spark vui lòng nhấp vào tại đây.

Kết luận

Trong bài đăng này, chúng tôi đã trình bày cách bạn có thể sử dụng dữ liệu OPRA có độ chính xác cao từ Lịch sử đánh dấu-PCAP của LSEG để thực hiện phân tích chi phí giao dịch bằng Athena Spark. Tính sẵn có của dữ liệu OPRA một cách kịp thời, cùng với những cải tiến về khả năng tiếp cận của AWS Data Exchange cho Amazon S3, giúp giảm thời gian phân tích một cách chiến lược cho các công ty muốn tạo ra thông tin chi tiết có thể hành động cho các quyết định giao dịch quan trọng. OPRA tạo ra khoảng 7 TB dữ liệu Parquet được chuẩn hóa mỗi ngày và việc quản lý cơ sở hạ tầng để cung cấp phân tích dựa trên dữ liệu OPRA là một thách thức.

Khả năng mở rộng của Athena trong việc xử lý dữ liệu quy mô lớn cho Lịch sử đánh dấu – PCAP cho dữ liệu OPRA khiến nó trở thành lựa chọn hấp dẫn cho các tổ chức đang tìm kiếm giải pháp phân tích nhanh chóng và có thể mở rộng trong AWS. Bài đăng này cho thấy sự tương tác liền mạch giữa hệ sinh thái AWS và dữ liệu Lịch sử đánh dấu-PCAP cũng như cách các tổ chức tài chính có thể tận dụng sức mạnh tổng hợp này để thúc đẩy việc ra quyết định dựa trên dữ liệu cho các chiến lược đầu tư và giao dịch quan trọng.

Về các tác giả

Pramod Nayak là Giám đốc Quản lý Sản phẩm của Nhóm Độ trễ Thấp tại LSEG. Pramod có hơn 10 năm kinh nghiệm trong ngành công nghệ tài chính, tập trung vào phát triển phần mềm, phân tích và quản lý dữ liệu. Pramod là cựu kỹ sư phần mềm và đam mê dữ liệu thị trường và giao dịch định lượng.

LakshmiKanth Mannem là Giám đốc sản phẩm trong Nhóm có độ trễ thấp của LSEG. Ông tập trung vào dữ liệu và các sản phẩm nền tảng cho ngành dữ liệu thị trường có độ trễ thấp. LakshmiKanth giúp khách hàng xây dựng các giải pháp tối ưu nhất cho nhu cầu dữ liệu thị trường của họ.

Vivek Aggarwal là Kỹ sư dữ liệu cấp cao trong Nhóm có độ trễ thấp của LSEG. Vivek nỗ lực phát triển và duy trì các đường dẫn dữ liệu để xử lý và phân phối nguồn cấp dữ liệu thị trường đã nắm bắt và nguồn cấp dữ liệu tham chiếu.

Alket Memushaj là Kiến trúc sư chính trong nhóm Phát triển Thị trường Dịch vụ Tài chính tại AWS. Alket chịu trách nhiệm về chiến lược kỹ thuật, làm việc với các đối tác và khách hàng để triển khai ngay cả khối lượng công việc thị trường vốn đòi hỏi khắt khe nhất lên Đám mây AWS.

Dấu thời gian:

Thêm từ Dữ liệu lớn AWS