Ускорение обработки тиковых данных L2 (Orderbook): Polars против Pandas

Суть: Использование библиотеки polars вместо pandas для обработки L2-данных стакана (Orderbook) позволяет ускорить расчеты в 5–10 раз и снизить потребление памяти за счет многопоточного движка на Rust и ленивых вычислений (LazyFrame). В статье представлен готовый бенчмарк расчета Spread, Order Book Imbalance (OBI) и Micro-price с последующим ресемплингом.

Содержание

Исходный код

Ниже представлен готовый скрипт для генерации 1 000 000 строк синтетических L2-данных и сравнения скорости расчета ключевых микроструктурных метрик на pandas и polars.

import time
import numpy as np
import pandas as pd
import polars as pl

# Генерация синтетических L2-данных (Orderbook)
def generate_mock_data(n_rows=1_000_000):
    timestamps = pd.date_range(start="2023-01-01", periods=n_rows, freq="10ms")
    np.random.seed(42)
    mid_prices = 100 + np.cumsum(np.random.normal(0, 0.01, n_rows))
    spreads = np.random.uniform(0.01, 0.05, n_rows)
    
    bid_price_0 = mid_prices - spreads / 2
    ask_price_0 = mid_prices + spreads / 2
    bid_qty_0 = np.random.randint(1, 100, n_rows).astype(np.float64)
    ask_qty_0 = np.random.randint(1, 100, n_rows).astype(np.float64)
    
    df = pd.DataFrame({
        "timestamp": timestamps,
        "bid_price_0": bid_price_0,
        "bid_qty_0": bid_qty_0,
        "ask_price_0": ask_price_0,
        "ask_qty_0": ask_qty_0
    })
    return df

# Обработка через Pandas
def process_pandas(df):
    df = df.copy()
    df["spread"] = df["ask_price_0"] - df["bid_price_0"]
    df["obi"] = (df["bid_qty_0"] - df["ask_qty_0"]) / (df["bid_qty_0"] + df["ask_qty_0"])
    df["micro_price"] = (df["bid_price_0"] * df["ask_qty_0"] + df["ask_price_0"] * df["bid_qty_0"]) / (df["bid_qty_0"] + df["ask_qty_0"])
    
    # Ресемплинг в 1-секундные бары
    resampled = df.resample("1s", on="timestamp").agg({
        "spread": "mean",
        "obi": "mean",
        "micro_price": "last"
    })
    return resampled

# Обработка через Polars (Lazy API)
def process_polars(df_pl):
    result = (
        df_pl.lazy()
        .with_columns([
            (pl.col("ask_price_0") - pl.col("bid_price_0")).alias("spread"),
            ((pl.col("bid_qty_0") - pl.col("ask_qty_0")) / (pl.col("bid_qty_0") + pl.col("ask_qty_0"))).alias("obi"),
            ((pl.col("bid_price_0") * pl.col("ask_qty_0") + pl.col("ask_price_0") * pl.col("bid_qty_0")) / (pl.col("bid_qty_0") + pl.col("ask_qty_0"))).alias("micro_price")
        ])
        .group_by_dynamic("timestamp", every="1s")
        .agg([
            pl.col("spread").mean().alias("spread_mean"),
            pl.col("obi").mean().alias("obi_mean"),
            pl.col("micro_price").last().alias("micro_price_last")
        ])
        .collect()
    )
    return result

if __name__ == "__main__":
    print("Генерация данных...")
    df_pandas = generate_mock_data(5_000_000)
    df_polars = pl.from_pandas(df_pandas)
    
    print(f"Данные сгенерированы: {len(df_pandas)} строк.\n")
    
    # Тест Pandas
    start_time = time.time()
    res_pandas = process_pandas(df_pandas)
    pandas_duration = time.time() - start_time
    print(f"Время выполнения Pandas: {pandas_duration:.4f} сек")
    
    # Тест Polars
    start_time = time.time()
    res_polars = process_polars(df_polars)
    polars_duration = time.time() - start_time
    print(f"Время выполнения Polars: {polars_duration:.4f} сек")
    
    print(f"Ускорение в {pandas_duration / polars_duration:.2f} раз!")

Разбор параметров

В коде используются ключевые методы оптимизации polars, которые обеспечивают кратное преимущество над pandas:

lazy(): Переводит DataFrame в режим ленивых вычислений (LazyFrame). Вместо немедленного выполнения операций строится направленный ациклический граф (DAG), который оптимизируется перед запуском (например, объединяются схожие операции и исключаются лишние копирования в памяти).
with_columns(): Позволяет вычислять несколько новых признаков параллельно. В отличие от последовательного присвоения в pandas, создание колонок в polars происходит в рамках одного прохода по памяти.
group_by_dynamic(): Специализированный высокопроизводительный метод для работы с временными рядами. Он заменяет медленный resample из pandas, эффективно группируя тики по динамическим временным окнам (параметр every='1s') силами многопоточного Rust-движка.
collect(): Запускает оптимизированный граф вычислений на выполнение и возвращает физический DataFrame.

Как запустить

Для запуска бенчмарка вам понадобятся установленные библиотеки polars, pandas, numpy и pyarrow. Установите их через ваш пакетный менеджер:

pip install polars pandas numpy pyarrow

Перед расчетом сложных метрик часто требуется предварительная подготовка данных, аналогичная тому, как выполняется Очистка OHLCV данных в Pandas: Удаление выбросов и NaN.

Полученные секундные бары с микро-ценами и OBI можно использовать для построения торговых систем, например, когда проводится Бэктестинг Pairs Trading на Python: Тест Йохансена (Johansen Test).

Для оценки рисков полученной высокочастотной стратегии отлично подойдет Симуляция Монте-Карло для крипто-портфеля в Python scipy.

Скопируйте исходный код в файл benchmark.py и запустите его. На объеме в 5 000 000 тиков polars демонстрирует превосходство по скорости в 6–10 раз, при этом потребляя значительно меньше оперативной памяти.