trade-learn

trade-learn logo

Documentation | Changelog | 中文简体 | 日本語

Python for Strategy & Research, Rust for Event-Driven Backtest Engine.

PyPI version Python versions License Changelog

trade-learn aims to eliminate the long-standing friction between quantitative research ("Learn") and backtest execution ("Trade"). By adopting a hybrid architecture of "Python for strategy logic + Rust for native backtest core," it achieves a 110x+ performance leap in multi-asset backtesting while ensuring 100% rigorous semantic alignment with Backtrader. It compresses large-scale strategy validation from hours to seconds, providing truly iterative research efficiency for index enhancement and machine learning strategies.

Beyond high performance, trade-learn provides a complete research infrastructure. With built-in JupyterLab and MLflow, it seamlessly links factor mining, strategy validation, and experiment auditing into a reproducible, traceable, and auditable full-lifecycle research pipeline. This elevates the research process from "result-oriented" to a systematically managed engineering workflow, allowing researchers to focus on the core strategy logic.

trade-learn research flow

From Extreme Efficiency to Scientific Decision-Making: Building on the efficiency gains of the research pipeline, trade-learn further addresses the core "scientific rigor" of quantitative research. To combat the "pseudo-correlation" risks common in machine learning strategies, we have deeply integrated Causal Inference into the research workflow. By identifying true causal driving paths, it reduces out-of-sample decay risks and helps build highly explainable and robust quantitative strategy systems.

Implementation Path

trade-learn rejects the simple stacking of features. Instead, it balances professional depth with research efficiency through a unique "Dual-Mode, Dual-Core" design. The Engine layer strictly aligns with Backtrader semantics for logic correctness, while the Lite layer provides a minimal Pythonic interface for rapid iteration.

You can define the depth of your strategy based on the research stage:

Engine Mode (Deep Research): Fully aligns with Backtrader semantics, supporting the complete Analyzer/Sizer/Signal ecosystem. Ideal for building complex, production-grade systems with precise logic.
Lite Mode (Agile Validation): Follows the minimalism of backtesting.py, supporting direct connection to model weights. Perfect for high-frequency iteration and prototype validation during the factor mining stage.

In terms of ecosystem, trade-learn provides comprehensive indicator support, compatible with TA-Lib, Pandas-TA-Classic, TDX, and TradingView, while allowing flexible expansion of custom indicators and data sources.

Core Highlights

⚡️ High-Performance Core: Rust-Driven Velocity

Rust Hybrid Power: The matching engine and core calculations are powered by Rust, providing 28x speedup for single assets and 110x+ for multi-asset rebalancing compared to Backtrader.
Automatic Runner Scheduling: Automatically selects between "Single-Stream Bar-by-Bar" or "Batch Panel" processing based on data shape. Optimized memory layout for Index Enhancement scenarios.

🛡️ Rigorous Finance: 100% Backtrader Alignment

Engine-Level Alignment: Full support for the Analyzer/Sizer/Signal system, ensuring zero logical divergence from the Backtrader Oracle.
Lite Minimalist Expression: Lightweight syntax built on the same runtime. Features a built-in target_weights interface to convert ML model outputs into backtest decisions instantly.

🧪 Causal Research: Scientific Workflow Beyond Correlation

Causal-First Feature Selection: Built-in causal discovery algorithms like PC/FCI to identify true causal paths and combat "pseudo-correlation" and overfitting.
Full-Link Pipeline: Seamlessly couples feature engineering, causal screening, scoring models, portfolio weights, and backtest reports into a reproducible experimental loop.

📦 Modular Platform: Lightweight Core, On-Demand Expansion

Decoupled Core: The default installation includes only the high-performance backtest kernel with minimal dependencies, making it easy to integrate into servers or automated trading systems.
Elastic Expansion: One-click activation of the integrated research environment (JupyterLab + MLflow + AI Assistant) via [lab] or [all] extras.

🌍 Global Vision: Multi-Standard Indicators & Modern Ecosystem

Dual-Market Standards: Explicit support for TDX (China) and TradingView (International) indicator standards, with deep compatibility for TA-Lib and Pandas-TA-Classic.
Modern Tools: Out-of-the-box HTML interactive reports, MLflow experiment tracking, and deep JupyterLab/MCP integration.

Causal Quant: Bridging the "Pseudo-Correlation" Trap

Most quantitative research stops at Correlation, which often leads to factors performing well in backtests but failing rapidly in live trading (overfitting). trade-learn helps you identify the true drivers of returns through its built-in Causal Discovery mechanism:

Causal Feature Selection: Use CausalSelector with PC/FCI algorithms to strip away pseudo-correlated factors caused by "common observations," keeping only features with direct driving capability for returns.
Resisting Out-of-Sample Decay: Alpha factors identified via causal graphs are more resilient to market regime shifts, effectively reducing the performance gap between research and live trading.
Industrial Integration: Deeply integrated with the causal-learn ecosystem, making advanced causal inference as seamless as calling corr().

Who is it for?

Agile Developers & Prototypers: Convert ideas into backtest reports in just a few lines of code, enjoying a backtesting.py-like lightweight experience.
Index Enhancement & Portfolio Managers: Simulate rebalancing for 1000+ assets in seconds using the Rust Panel Runner.
ML & Factor Researchers: A one-stop automated loop from feature engineering and Causal Discovery to MLflow-tracked model training and backtesting.
Backtrader Power Users: Modernize your reporting and speed up your research while retaining the mature event-driven semantics you trust.
Cross-Market & Multi-Strategy Teams:
- Cross-market consistency: Cover A-shares (TDX) and global markets (TradingView) with consistent indicator standards and reporting.
- Unified strategy operations: Manage rule-based and model-based strategies in one stack, avoiding fragmented research and maintenance workflows.
Causal Inference Explorers: Bring causal graph methods into factor selection to remove pseudo-correlations and build more explainable, robust quantitative systems.

Installation

pip install trade-learn

Get the latest version:

pip install git+https://github.com/MuuYesen/trade-learn.git@master

Optional extras:

extra	Usage
`[tdx]`	OpenTDX data / China-market indicator dependencies
`[tv]`	TradingView datafeed and PyneCore-backed TradingView indicators
`[talib]`	TA-Lib indicator namespace
`[indicators]`	TDX + TradingView + TA-Lib indicator backends
`[ml]`	Causal ML dependencies
`[research]`	Research acceleration utilities such as Numba
`[duckdb]`	DuckDB bars backend
`[lab]`	JupyterLab / Jupyter AI / MCP / Pygwalker environment
`[mlflow]`	MLflow tracking server and artifact logging
`[all]`	Full environment (Lab, MLflow, indicators, ML, DuckDB, etc.)

💡 Installation Tip: The default install includes only the core engine. For the full research experience, use [all]:
pip install "trade-learn[all]"
Launch with tradelearn lab. Access JupyterLab at port 8888 and MLflow at 5050.

Quick Start

Lite — The Shortest Path (Ideal for rapid validation, teaching, and target-weight portfolios):

import tradelearn.lite as tl
from tradelearn.data import TradingViewProvider

class LiteSmaCross(tl.Strategy):
    fast = 10
    slow = 20

    def init(self):
        self.fast_ma = tl.tdx.MA(self.data.close, N=self.fast)
        self.slow_ma = tl.tdx.MA(self.data.close, N=self.slow)
        self.start_on_bar(self.slow + 1)

    def next(self):
        if self.fast_ma[0] > self.slow_ma[0] and not self.position():
            self.buy(size=100)
        elif self.fast_ma[0] < self.slow_ma[0] and self.position():
            self.position().close()

provider = TradingViewProvider(n_bars=5000)
bars = provider.history_ohlc("NASDAQ:AAPL", start="2023-01-01", end="2024-01-01")

bt = tl.Backtest(bars, LiteSmaCross, cash=100_000, commission=0.0003, trade_on_close=True)
stats = bt.run()

print(stats.summary)
bt.plot()
bt.report("report.html")

[!TIP] Multi-asset logic: In multi-asset backtests, the strategy binds to self.data by default (the primary data feed). The example above therefore makes decisions from the first asset even if multiple assets are provided. To trade multiple assets independently, iterate over self.datas in init and create indicators for each feed.

Engine — Backtrader Style (Ideal for complex portfolios and future paper/live modes):

import tradelearn.engine as bt
from tradelearn.data import TradingViewProvider

class SmaCross(bt.Strategy):
    params = (("fast", 10), ("slow", 20))

    def __init__(self):
        self.fast = bt.tdx.MA(self.data.close, N=self.p.fast)
        self.slow = bt.tdx.MA(self.data.close, N=self.p.slow)

    def next(self):
        if not self.position and self.fast[0] > self.slow[0]:
            self.buy(size=100)
        elif self.position and self.fast[0] < self.slow[0]:
            self.close()

provider = TradingViewProvider(n_bars=5000)
bars = provider.history_ohlc("NASDAQ:AAPL", start="2023-01-01", end="2024-01-01")

cerebro = bt.Cerebro(trade_on_close=True)
cerebro.setcash(100_000)
cerebro.setcommission(0.0003)
cerebro.adddata(bars, name="AAPL")
cerebro.addstrategy(SmaCross)

[strategy] = cerebro.run()
print(strategy.stats.summary)

cerebro.plot()
cerebro.report("report.html")

[!TIP] Multi-asset logic: In multi-asset backtests, the strategy binds to self.data by default (the primary data feed). The example above therefore makes decisions from the first asset even if multiple assets are provided. To trade multiple assets independently, iterate over self.datas in init and create indicators for each feed.

Research Pipeline Example

The README keeps the shortest readable version. Full scripts are available at examples/research/index_enhance_lite_pipeline.py and examples/research/index_enhance_engine_pipeline.py.

1. Research: build features from raw bars and split train/test data

import tradelearn.research as research
import tradelearn.research.preprocess as pp

feature_set = research.FeatureSet(
    {
        "alpha": lambda p: p.close.pct_change(20)
        / p.close.pct_change().rolling(20).std(),
        "size": lambda p: p.close,
    },
    target={"label": lambda p: p.close.shift(-20) / p.close - 1.0},
)

features = feature_set.fit_transform(bars, include_target=True).dropna()
train, test = research.time_split(features, split="2023-09-01", level="timestamp")

2. Pipeline: preprocess, score with a model, and generate weights

from sklearn.ensemble import GradientBoostingRegressor
import tradelearn.research.portfolio as pf

pipe = research.Pipeline(
    [
        pp.Winsorizer(columns=["alpha"], limits=(0.05, 0.95)),
        pp.Neutralizer(columns=["alpha"], exposures=["size"]),
        pp.StandardScaler(columns=["alpha"]),
    ]
)
train = pipe.fit_transform(train)
test = pipe.transform(test)

model = GradientBoostingRegressor(random_state=7)
model.fit(train[["alpha"]], train["label"])
scores = research.ModelScorer(model, features=("alpha",), current=False).predict(test)

weights = pf.Allocator(
    select=pf.TopK(k=2),
    weight=pf.EqualWeight(gross=0.95),
    constrain=pf.Constraints(max_weight=0.5, normalize=True),
).build(scores)

3. Portfolio: hand target weights to Lite / Engine for execution

class LitePortfolio(tl.Strategy):
    def next(self):
        if len(self.data) % 20 == 0:
            self.target_weights(self.research_result.weights[0], close_missing=True)


test_bars = research.split_bars(bars, split="2023-09-01")
stats = tl.Backtest(test_bars, LitePortfolio, cash=100_000).run(
    research_result=research_result
)

4. Live-style: infer only from the currently visible window inside the strategy

Offline research pipelines are useful for training and review. For semantics closer to live trading, pass the model and allocator into strategy parameters and use history_panel() inside next() so the strategy only reads data that has already happened.

class LiveStylePortfolio(tl.Strategy):
    lookback = 20

    def init(self):
        self.start_on_bar(self.lookback)

    def next(self):
        if len(self.data) % 20 != 0:
            return

        panel = self.history_panel(self.lookback)
        features = self.feature_set.transform(panel).dropna()
        scores = self.scorer.predict(features)
        weights = self.allocator.build(scores)
        self.target_weights(weights, close_missing=True)

Full versions:

Goal	Full script
Lite research + backtest + report + MLflow	`examples/research/index_enhance_lite_pipeline.py`
Engine research + backtest + report + MLflow	`examples/research/index_enhance_engine_pipeline.py`
Lite live-style current-window inference	`examples/research/index_enhance_lite_live.py`
Engine live-style current-window inference	`examples/research/index_enhance_engine_live.py`
Engine Backtrader-style portfolio rebalancing	`examples/engine/11_target_percent_portfolio.py`
Asset-class portfolio strategy	`examples/engine/12_asset_class_portfolios.py`

Alignment & Performance

Local baselines focus on two core checks: whether results align and whether throughput is meaningfully faster than Backtrader. Full reproduction commands are available in benchmarks.

1. Single-Asset High-Frequency: SMA Cross (550k Bars)

Strategy idea: Run a standard dual moving average crossover. This stresses Rust's event-driven state maintenance and single-stream throughput over a long sequence.

Engine Mode	Time	Throughput (Bars/s)	Speedup	Final Equity	Orders	Closed Trades	Status
Tradelearn Lite	1.32s	414,990	27.9x	118,399.33	10,299	5,149	EXACT
Tradelearn Engine	3.37s	162,883	11.0x	118,399.33	10,299	5,149	EXACT
Backtrader (Oracle)	37.02s	14,854	1.0x	118,399.33	10,299	5,149	-

2. Large-Scale Index Enhance: Top-50 Target Weights (5.04M Bars)

Strategy idea: Simulate full-market stock selection and rebalancing across 1000 assets. This stresses Rust's panel-data memory layout and large-scale ML research workflow.

Engine Mode	Time	Throughput (Bars/s)	Speedup	Final Equity	Completed Orders	Rebalance Intents	Rebalances
Tradelearn Lite	2.40s	2,094,237	119.1x	4,199,638.26	23,249	23,249	239
Tradelearn Engine	4.11s	1,225,594	69.7x	4,199,638.26	23,249	23,249	239
Backtrader (Oracle)	286.53s	17,589	1.0x	4,199,638.26	23,249	23,249	239

Parity Commitment

trade-learn treats "benchmark parity" as a core engineering discipline. Every computed result must withstand strict scrutiny, with numerical alignment maintained across these layers:

Financial metrics parity: metrics (Sharpe, MaxDD, Sortino, etc.) match empyrical within rtol=1e-10.
Multi-source indicator parity:
- tl.pta (classic indicators) matches pandas-ta-classic within rtol=1e-10.
- tl.tdx (TDX semantics) matches MyTT within rtol=1e-10.
- tl.tv (TradingView semantics) matches pyneCore within rtol=1e-6.
Backtest engine parity:
- Decision layer: trade records (Trades) match the official Backtrader implementation with 0 difference in time, direction, and position.
- Equity layer: equity curves align within rtol=1e-6, and summary statistics align within rtol=1e-4.

[!IMPORTANT] We treat every numerical deviation with zero tolerance. All differences are registered and explained. See design notes → semantic consistency audit.

Full Documentation

Official online docs: https://muuyesen.github.io/trade-learn/
Local technical manual: docs/

Topic	Entry
First backtest in 30 lines	Quickstart
Lite / Engine usage	Lite Guide · Engine Guide
Architecture and boundaries	Architecture
Factor / ML / weight research pipeline	Research Guide
Dual-standard indicators (`tl.talib` / `tl.pta` / `tl.tdx` / `tl.tv`)	Indicators Guide
Performance baseline	Benchmarks
Kernel internals (contracts / matching / portfolio / event loop)	Design Notes
Full API	API Reference

🚀 Roadmap

Based on the current engineering plan, trade-learn evolves along these core dimensions:

Backtest Engine & Core Foundation

Rust Hybrid Kernel: Clocked Multi-Data Runner, 110x+ speedup for multi-asset backtests.
Backtrader Semantic Parity: 100% matching consistency and shared runtime through bt.Strategy.
Index Enhancement Pipeline: Complete Data → Factor → Score → Weights → target_weights() workflow.
Automated Experiment Audit: Deep MLflow integration for code snapshots, parameters, metrics, and reports.
High-Performance Data Backend: DuckDB native connector has landed, supporting local second-level reads and cross-dimensional queries over hundreds of millions of bars.
Risk Model Integration: Barra-style risk exposure analysis and excess-return attribution.

Scientific Research Capabilities

Causal Discovery Foundation: Integrated CausalSelector (PC/FCI) to identify true alpha drivers during feature engineering.
Algorithm Expansion: Add GIES, Direct-LiNGAM, and other advanced algorithms for better explainability and stability.
Causal Closed Loop: Automate the loop across causal analysis, parameter optimization, and risk control.

Agent & AI Capabilities

MCP Knowledge Gateway: MCP Server is live, enabling structured API understanding and code generation for AI.
Agentic Strategy Diagnosis: Use LLMs to analyze backtest results, identify loss drivers, and suggest logic improvements.
LLM Factor Interpreter: Translate causal discovery results into intuitive financial investment logic.

Engineering & ML Lifecycle

Model Registry: MLflow-based model registry for full-lifecycle tracking of feature fingerprints and model versions.
Distributed Parameter Optimization: Multi-machine parameter search and Monte Carlo simulation via Ray / Optuna.

Live Trading & Ecosystem Vision

Universal Live Event Link: Completed EventRunner semantics, enabling 100% code reuse between backtest and live trading.
Live Trading Connectivity: Integrate QMT, IBKR, and other brokers to complete the last mile from research to execution.
Agentic Quant Platform: Evolve into a natural-language-driven automation foundation for end-to-end quantitative research.

Disclaimer

This project is for academic research and technical exchange only and does not constitute any investment advice. Quantitative trading involves high risk; past performance is not indicative of future results. The developers are not responsible for any financial losses incurred through the use of this project. Invest at your own risk.

Acknowledgements

Quantopian · Trevor Stephens · PyWhy · dodid · DolphinDB · happydasch · mpquant · baobao1997

Contact

WeChat: 知守溪的收纳屋 · Email: muyes88@gmail.com

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

trade_learn-0.2.5.tar.gz (252.8 kB view details)

Uploaded Jul 20, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

trade_learn-0.2.5-cp314-cp314-win_amd64.whl (502.6 kB view details)

Uploaded Jul 20, 2026 CPython 3.14Windows x86-64

trade_learn-0.2.5-cp314-cp314-manylinux_2_28_x86_64.whl (643.3 kB view details)

Uploaded Jul 20, 2026 CPython 3.14manylinux: glibc 2.28+ x86-64

trade_learn-0.2.5-cp314-cp314-macosx_11_0_arm64.whl (592.8 kB view details)

Uploaded Jul 20, 2026 CPython 3.14macOS 11.0+ ARM64

trade_learn-0.2.5-cp313-cp313-win_amd64.whl (502.4 kB view details)

Uploaded Jul 20, 2026 CPython 3.13Windows x86-64

trade_learn-0.2.5-cp313-cp313-manylinux_2_28_x86_64.whl (643.2 kB view details)

Uploaded Jul 20, 2026 CPython 3.13manylinux: glibc 2.28+ x86-64

trade_learn-0.2.5-cp313-cp313-manylinux_2_28_aarch64.whl (631.6 kB view details)

Uploaded Jul 20, 2026 CPython 3.13manylinux: glibc 2.28+ ARM64

trade_learn-0.2.5-cp313-cp313-macosx_11_0_arm64.whl (593.1 kB view details)

Uploaded Jul 20, 2026 CPython 3.13macOS 11.0+ ARM64

trade_learn-0.2.5-cp312-cp312-win_amd64.whl (502.7 kB view details)

Uploaded Jul 20, 2026 CPython 3.12Windows x86-64

trade_learn-0.2.5-cp312-cp312-manylinux_2_28_x86_64.whl (644.0 kB view details)

Uploaded Jul 20, 2026 CPython 3.12manylinux: glibc 2.28+ x86-64

trade_learn-0.2.5-cp312-cp312-macosx_11_0_arm64.whl (594.0 kB view details)

Uploaded Jul 20, 2026 CPython 3.12macOS 11.0+ ARM64

trade_learn-0.2.5-cp311-cp311-win_amd64.whl (505.6 kB view details)

Uploaded Jul 20, 2026 CPython 3.11Windows x86-64

trade_learn-0.2.5-cp311-cp311-manylinux_2_28_x86_64.whl (648.1 kB view details)

Uploaded Jul 20, 2026 CPython 3.11manylinux: glibc 2.28+ x86-64

trade_learn-0.2.5-cp311-cp311-macosx_11_0_arm64.whl (599.0 kB view details)

Uploaded Jul 20, 2026 CPython 3.11macOS 11.0+ ARM64

trade_learn-0.2.5-cp310-cp310-win_amd64.whl (505.5 kB view details)

Uploaded Jul 20, 2026 CPython 3.10Windows x86-64

trade_learn-0.2.5-cp310-cp310-manylinux_2_28_x86_64.whl (647.8 kB view details)

Uploaded Jul 20, 2026 CPython 3.10manylinux: glibc 2.28+ x86-64

trade_learn-0.2.5-cp310-cp310-macosx_11_0_arm64.whl (599.3 kB view details)

Uploaded Jul 20, 2026 CPython 3.10macOS 11.0+ ARM64

File details

Details for the file trade_learn-0.2.5.tar.gz.

File metadata

Download URL: trade_learn-0.2.5.tar.gz
Upload date: Jul 20, 2026
Size: 252.8 kB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/6.1.0 CPython/3.13.14

File hashes

Hashes for trade_learn-0.2.5.tar.gz
Algorithm	Hash digest
SHA256	`da4aef688cbab607cc7751255976de97b4aa6358ee95575508e3a9dd92a1daa4`
MD5	`1e7798a1274584c9ba4c4c550f6d58d9`
BLAKE2b-256	`db8814e657ec031ad44d2acc403e8a72a92d4391647f1833d77f4e41ac89e0fa`

Algorithm	Hash digest
SHA256	`41dae67a2d82d05615e8da0fd30e14dcc23e7c299c99b07315e4b01f034b94be`
MD5	`ad461ff9746edb94bf1faec378ec4f2e`
BLAKE2b-256	`2787fee3492ae08fb68238fe688571d7b770baa44c786b064f80aa03a366a889`

Algorithm	Hash digest
SHA256	`968a244e842d0bfe69b90c360d780e283207b0aa555a3678b7b9bf1ff6cba7ad`
MD5	`0ff7664bc1e1e0f79cca2e4586df6bce`
BLAKE2b-256	`ed61a65364c9bdbdd3f0d1704542169411d491ab9d7f8ff0bc652247d7f6a3b1`

Algorithm	Hash digest
SHA256	`3622d800e1fdc67fc9a6ffb39538e965fbdec78fc9d1b9093fd694018a1c3f70`
MD5	`563196b091b8bd5cb1e10b582e6922f4`
BLAKE2b-256	`a3de8873ea7dd107de8901641e0832874979404ad7257d49e630da5e08ad0028`

Algorithm	Hash digest
SHA256	`fe4a2b45a3e17ea3f383f73ddb4e70f41df28f1ac8e75f8adadcd66a3c8d1902`
MD5	`813f82923e8c6f830e02138247b3da39`
BLAKE2b-256	`529f6aafebea9874868bccc61ec8c326567dca2bd06dba9d1c14865e51fc02f6`

Algorithm	Hash digest
SHA256	`0678143ccb52a2d7e25b962b636eb2df2dba186b256b70389d75d736b5105279`
MD5	`f111f1af1575c3fe6faf0d452662f029`
BLAKE2b-256	`3df708b576458fbc0dd0fa09f41b40d4974c33ee23fa12e08ec279060b70f409`

Algorithm	Hash digest
SHA256	`bdc8187d292ce08270d17057a5e02f53d2a6a5128cd1f7bb34a0503bc04ab45d`
MD5	`75beac90204c7c99ccad19590827d9b0`
BLAKE2b-256	`5db0cf35ac9416f8f21a3f59611949f6eebd7fd0ba2d02beb3384c1df7c97805`

Algorithm	Hash digest
SHA256	`1b8a9a7cc3be172e152fd84a9e9bb902d41d2f1aca54e2d631f47b5fb9ed3b9e`
MD5	`42a2d9ed9a2537102337835812e00e27`
BLAKE2b-256	`70eee0340e6f091a72feda206818dc1844eac4a4bfc06f6dd20cb21e2db3117d`

Algorithm	Hash digest
SHA256	`af1fda21bacf23ff999906930ec85fede89e8b04788447b3486fc00046bbe0b8`
MD5	`565e555cece93a08a8d3372ea82b6abf`
BLAKE2b-256	`ba0c1d76d5f5db50a095897ceb4722747b0d1115e8e138c15a9f880a9484ba18`

Algorithm	Hash digest
SHA256	`96139f59439782ed150b9e090b47a0ea0d721788060ded863ea433b029e1c41c`
MD5	`f84b91844994c854c5f8d2c2d29213f5`
BLAKE2b-256	`6e97b8f7a76125a02d71043d83842aa20094491850fae517169493dc1c818601`

Algorithm	Hash digest
SHA256	`f3feadd36e82411c37f7f04e76683aa67d157bd2ec29840202351ce8c3951e78`
MD5	`5bb7370eb7ab90b37767aa21b4edb33e`
BLAKE2b-256	`472bacb7a3d9ac6bcaa901b3088440cc7cb257b06ccadf5017d242363c510bfe`

Algorithm	Hash digest
SHA256	`70abd9b90b0f5ae92836346da401c45ecc3c8aa16f6dc364fd139d0ab4a8a976`
MD5	`3f6979439cc492e6a769b5d2f0643c96`
BLAKE2b-256	`fa52d5776c7a3e7567863cdf40f8b29bdeb4b03d994f01a5b96cc6d3527bb584`

Algorithm	Hash digest
SHA256	`cef71cc3e5e3e79580ac8045088302cac67e4b301cb3d30e527bc58a34042bf9`
MD5	`8c800302eae72eeefaac02da07f3c28f`
BLAKE2b-256	`c4d7a66de4f2b468f0b11744858d6e25b69a969e91f1a9c9ab14f726201081e8`

Algorithm	Hash digest
SHA256	`fd511717c09a2d902399585197b513e74d2024c1151e9bee69060cd07cb121aa`
MD5	`4ae89a627dd15278e072aa3700d008e6`
BLAKE2b-256	`dbd29ac0a7d7ff81d4fee3246b58ff1dc701fcad7f3499b93edb23ee803ae25c`

Algorithm	Hash digest
SHA256	`f6b3419275dbad6a34cac6d14197d0f18e222a3a9e802d4245ba9d91accff624`
MD5	`e7e018a22ff05a00939b54f07a95f1eb`
BLAKE2b-256	`87097f3e8f21fc3aabcd7c8bd3ff9841876a7ea0dc3e7dfd101a8f096f242b9a`

Algorithm	Hash digest
SHA256	`5186ed4bbf8a53a05ef3039595d9521c38845801b2358681f7c328746b160e4d`
MD5	`b7ff28ac478f54922be2772756b5cb09`
BLAKE2b-256	`5031fa8fcda566efdb818931e563146944b611f04215c9643341fbd1643fb389`

Algorithm	Hash digest
SHA256	`c1ed22cfe811a74735fe20e598a54189d8ee406fe0f7e9771fee3dcb2037e891`
MD5	`793aab7b4afb01485041c6b187a4ab0d`
BLAKE2b-256	`c1a585d5124fbb65a0ceb3236787c9f595e4c4a0f34cd3b96c434bcae37793b2`

trade-learn 0.2.5

Implementation Path

Core Highlights

⚡️ High-Performance Core: Rust-Driven Velocity

🛡️ Rigorous Finance: 100% Backtrader Alignment

🧪 Causal Research: Scientific Workflow Beyond Correlation

📦 Modular Platform: Lightweight Core, On-Demand Expansion

🌍 Global Vision: Multi-Standard Indicators & Modern Ecosystem

Causal Quant: Bridging the "Pseudo-Correlation" Trap

Who is it for?

Installation

Quick Start

Research Pipeline Example

Alignment & Performance

1. Single-Asset High-Frequency: SMA Cross (550k Bars)

2. Large-Scale Index Enhance: Top-50 Target Weights (5.04M Bars)

Parity Commitment

Full Documentation

🚀 Roadmap

Backtest Engine & Core Foundation

Scientific Research Capabilities

Agent & AI Capabilities

Engineering & ML Lifecycle

Live Trading & Ecosystem Vision

Disclaimer

Acknowledgements

Contact

Project links

Key dates

1 maintainer

Credits

GitHub Statistics

License

Requires

Provides Extra

Classifiers

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details