qweave

中文

A Polars-native factor research engine powered by Rust. qweave takes you from composable alpha computation and leakage-aware forward-return labels to IC, quantile, turnover, and interactive report analysis in one DataFrame pipeline.

• ⚡ 4.8M rows × 158 factors in ~2.2 s: all Qlib Alpha158 factors on a 6,000-symbol × 800-day panel in one batch run (measured on a Ryzen 9 9950X).
• 🆚 23.85× faster than Qlib Alpha158DL: measured on the same panel, the same factor set, and 32 threads for every engine; 2.56× faster end to end than KunQuant's JIT C++ path, with no C++ toolchain required. Commands and full data in Benchmarks.
• 🧩 450 built-in classic factors: WorldQuant Alpha101 + Qlib Alpha158 + Guotai Junan Alpha191, with time-series and cross-sectional operators in one expression API — select, remap inputs, mix, and execute them as one batch.
• 📊 Interactive report in one line: result.view() opens the embedded Vue + ECharts interface with per-factor quantile returns, monthly IC, and long-short diagnostics.

Bring your own Polars market-data panel. Keep your data pipeline. Move the expensive factor-research loop into Rust.

qweave is for quantitative researchers who already manage data with Parquet/Polars and want fewer per-factor Python loops, repeated rolling computations, and matrix-alignment problems. It focuses on whether factors carry stable information about future returns. It is not a data vendor, matching simulator, or full investment platform.

Quick Start

Install from PyPI (Python 3.10+):

pip install qweave

v0.6.1 adds Skew, Kurt, EMA, and standard WMA, with incremental rolling Skew/Kurt. See the v0.6.1 release notes for Qlib alignment and the Rust WMA migration.

Platform-specific wheels are also available from GitHub Releases. For source builds see the Development Guide.

From Market Data To A Factor Report

The repository includes a deterministic synthetic panel with 80 assets and 320 trading days. This example mixes two classic factors with one custom expression, then creates labels, evaluates the factors, and opens the interactive report:

import polars as pl
import qweave as qw

df = pl.read_parquet("examples/data/sample_daily.parquet")

alphas = qw.worldquant_alpha101({}, alphas=["alpha13", "alpha101"])
alphas.append(
    (-(qw.col("close") / qw.col("close").delay(20) - qw.lit(1.0)))
    .alias("mean_reversion_20")
)

df = qw.with_alphas(df, "asset", "date", alphas)
df = qw.with_labels(
    df,
    symbol_col="asset",
    time_col="date",
    horizons=[1, 5, 20],
    entry_lag=1,
    tradable_col="tradable",
)

result = qw.evaluate(
    df,
    symbol_col="asset",
    time_col="date",
    factor_cols=["alpha13", "alpha101", "mean_reversion_20"],
    quantiles=5,
    min_cs_count=30,
    tradable_col="tradable_entry",
)

print(result.summary)
result.view()   # opens the interactive evaluation report in your browser

Or run the complete example directly:

python examples\quickstart.py

Why qweave

• DataFrame in, DataFrame out: qweave takes and returns Polars DataFrames directly — no converting the panel to NumPy arrays and stitching results back, and no migration to a dedicated data provider.
• Cross-sectional and time-series factors in the same expression: cross-sectional operators like rank and group_neutralize live in the same DAG as rolling time-series operators, so one compute_alphas call runs everything — no staged provider/handler workflow that fetches features first and organizes cross-sectional computation separately.
• Common time-series statistics: ts_skew, ts_kurt, mean-seeded ema, and standard linear wma use consistent period arguments; see the Qlib operator migration reference for differences.
• Execute the whole factor batch once: expressions enter one Rust DAG with common-subexpression reuse, intermediate-slot reuse, fused elementwise chains, and node-level parallelism.
• 450 composable classic factors: WorldQuant Alpha101, Qlib Alpha158, and Guotai Junan Alpha191 use the same API as custom expressions, so they can be selected, remapped, mixed, and executed together.
• Reports included: result.view() opens the Vue + ECharts interactive interface with per-factor drill-down. Thousand-factor workloads can stream results to Parquet.

Performance: Head-To-Head With Qlib And KunQuant

Measured on Windows 11 / Ryzen 9 9950X (16 cores, 32 threads) / 61.7 GiB memory, on the same 6,000-symbol × 800-day (4.8M-row) synthetic OHLCV panel, 32 threads for every engine, best of three runs after one warmup. KunQuant is measured end to end in f64, including input/output DataFrame conversion and JIT compilation:

Where the speed comes from: sorting, rolling windows, cross-sectional operators, and evaluation statistics run on the Rust hot path; the whole expression batch enters one DAG with common-subexpression reuse, slot reuse, and node-level parallelism managed by the engine. Full environment, commands, and publishing conventions in Benchmarks.

Factor Evaluation: Leakage-Free, Everything In One Run

Signal T ── entry_lag ──> Entry T+1 ── horizon h ──> Exit T+1+h

• T+1 entry by default, no look-ahead; halts and missing rows cannot silently shorten the holding period, and entry-day tradability is aligned back to the signal day automatically.
• One evaluate call produces IC/RankIC, quantile returns, turnover, rank autocorrelation, and long-short diagnostics, with Newey–West t-statistics correcting overlapping-horizon significance.
• result.view() opens the interactive report directly; thousand-factor runs can stream to Parquet.

See Factor Evaluation for exact calibers and parameters.

When To Choose qweave

• Your market data already lives in a Parquet/Polars pipeline and you do not want to migrate to a platform-specific data format or a staged provider/handler workflow just to compute factors.
• You compute and evaluate tens to thousands of factors at a time, and per-factor Python loops have become the bottleneck of research iteration.
• You are building automated factor mining or a research agent: an easy-to-write expression API, high-throughput batch execution, and unified evaluation calibers make qweave a natural kernel for an agent's "generate → compute → evaluate" experiment loop.

When you need a full platform with data ingestion, model training, and backtest experiment management, Qlib is the better fit — and qweave can be embedded in such platforms or agent systems as the factor computation and evaluation kernel. See Comparison for details.

Roadmap

• An experiment kernel for research agents: an easy-to-write expression API, high-throughput batch execution, and unified evaluation calibers powering the automated "generate factors → batch compute → strict evaluate" factor-mining loop.
• Expand the built-in factor libraries and time-series/cross-section operators.
• Keep improving the interactive report as the default way to inspect evaluation results.

Documentation Path

Follow the documentation home in order:

1. Runnable example
2. Python Expression API
3. WorldQuant 101 / Qlib Alpha158 / Guotai Junan Alpha191
4. Factor Evaluation
5. Architecture / Benchmarks

Project Status

The factor-computation, labeling, evaluation, and reporting workflow is usable today, while the API remains pre-1.0.

See CONTRIBUTING to contribute. This project is not affiliated with Guotai Junan Securities, WorldQuant, Microsoft, Qlib, or KunQuant.

License

MIT. See LICENSE.