exp 7: add workflow yaml

code/MANIFEST.txt

@@ -1,31 +0,0 @@
-# TradeAC custom-qlib-code snapshot (auto-generated)
-# parent repo HEAD : 25b4e59295fda8212184808beff8dff7dc0d7477
-#   tac-qlib/tac_qlib/contrib
-#   tac-qlib/tac_qlib/data
-# per-file hashes (git hash-object):
-  1b6298c4a5652f2e863cbdc385a1014a570fcd59  tac-qlib/tac_qlib/contrib/__init__.py
-  b419ee55ed455a1c45423d1c9025ca5cc0a98576  tac-qlib/tac_qlib/contrib/__pycache__/__init__.cpython-312.pyc
-  c76a9f17f680e74eea766eff27f7624359749ed6  tac-qlib/tac_qlib/contrib/data/__init__.py
-  2f6c67620aa2f9e6aaaef3369361d9b3eac3d6ca  tac-qlib/tac_qlib/contrib/data/__pycache__/__init__.cpython-312.pyc
-  fdd5923a70a399e8680913593ff111641947898e  tac-qlib/tac_qlib/contrib/data/__pycache__/handler.cpython-312.pyc
-  0dd25ef161c6e0f15eafc84886e7e1381deb38c3  tac-qlib/tac_qlib/contrib/data/handler.py
-  b151d139a0dcde87d74b21e7c4b729176ba5c39b  tac-qlib/tac_qlib/contrib/model/__init__.py
-  08dec87ccdf6bb5d2cf611ca3032a4280aaab8cf  tac-qlib/tac_qlib/contrib/model/__pycache__/__init__.cpython-312.pyc
-  6fb61946ea9a83dfb560de3717f5fbf482c4c00e  tac-qlib/tac_qlib/contrib/model/__pycache__/rank_ensemble.cpython-312.pyc
-  3e80f2e08b661ddd2f58ffe5a6196063fa41ae51  tac-qlib/tac_qlib/contrib/model/__pycache__/rank_gbdt.cpython-312.pyc
-  d3f051f3a8650c42fedc7b367b966f7c74fb5789  tac-qlib/tac_qlib/contrib/model/rank_ensemble.py
-  d03e6611338918d4aac5eea4adf26f85a3763652  tac-qlib/tac_qlib/contrib/model/rank_gbdt.py
-  c4ef84ffda2a611262412fe1127689c667f3d0c1  tac-qlib/tac_qlib/contrib/strategy/__init__.py
-  6ad10c2ebe37c16417e67c7aeb731ad1fcb6da2f  tac-qlib/tac_qlib/contrib/strategy/__pycache__/__init__.cpython-312.pyc
-  8d684b3216b040071d9ee4fa920a0e0c7486d278  tac-qlib/tac_qlib/contrib/strategy/__pycache__/optimal_stop.cpython-312.pyc
-  896ef74ae47bcd1ed388e1e5d9c8d70c28097fe9  tac-qlib/tac_qlib/contrib/strategy/kelly_dropout.py
-  79aaad9e39fcc740a773f4f63c512ce1086cfde0  tac-qlib/tac_qlib/contrib/strategy/optimal_stop.py
-  5b9acfb4340111b204249add7760bd53c6ae03f1  tac-qlib/tac_qlib/contrib/strategy/regime_gate.py
-  aa1ee880d52ceb5821d65973962099c2254f710a  tac-qlib/tac_qlib/contrib/strategy/top_bottom.py
-  fe60bacdfedd48617863be31f24b7c7daebfac5a  tac-qlib/tac_qlib/contrib/strategy/weekly_rebalance.py
-  92e6e90eb0cd0a25142034560f27adb6b705b1a8  tac-qlib/tac_qlib/data/__init__.py
-  7c4e6c345fad1978efe8860c0d977d0c02d6f8d9  tac-qlib/tac_qlib/data/__pycache__/__init__.cpython-312.pyc
-  99e602392d51663cb06d5c425000b1ed1e5a916b  tac-qlib/tac_qlib/data/__pycache__/config.cpython-312.pyc
-  020dcdcf288e4832c8cf2386351f78d5ceb4fe13  tac-qlib/tac_qlib/data/__pycache__/providers.cpython-312.pyc
-  53c9007a928841fd3c3b08450f9a6520ce1ac091  tac-qlib/tac_qlib/data/config.py
-  8d0644f6f0d1efb94798ed444cc73e63b643459b  tac-qlib/tac_qlib/data/providers.py

code/tac-qlib/tac_qlib/contrib/__init__.py

@@ -1,11 +0,0 @@
-from . import data  # noqa: F401  (registers tac_qlib.contrib.data)
-from . import model, strategy  # noqa: F401
-from .data import TACHandler  # noqa: F401
-from .model import RankICLGBModel  # noqa: F401
-from .strategy import OptimalStopControl  # noqa: F401
-
-__all__ = [
-    "TACHandler",
-    "RankICLGBModel",
-    "OptimalStopControl",
-]

code/tac-qlib/tac_qlib/contrib/data/__init__.py

@@ -1,3 +0,0 @@
-from .handler import TACHandler
-
-__all__ = ["TACHandler"]

code/tac-qlib/tac_qlib/contrib/data/handler.py

@@ -1,254 +0,0 @@
-"""TACHandler: a qlib DataHandlerLP that builds datasets from the TradeAC lake.
-
-This is the "custom DataHandler" entry point (Option B): the handler is referenced from the
-workflow yaml's ``dataset.handler`` and reads OHLCV + pre-computed ta-lib features straight
-from the lake parquet files through ``QLibDataLoader`` + the tac_qlib feature provider.
-
-The standard qlib processor pipeline (``infer_processors`` / ``learn_processors``) still runs
-on top, so existing recipes such as ``DropnaLabel``, ``CSZScoreNorm`` or ``RobustZScoreNorm``
-keep working unchanged.
-"""
-
-from __future__ import annotations
-
-import os
-from inspect import getfullargspec
-from typing import List, Optional, Tuple, Union
-
-from qlib.data.dataset import processor as processor_module
-from qlib.data.dataset.handler import DataHandlerLP
-from qlib.utils import get_callable_kwargs
-
-from ...data.config import (
-    LakeConfig,
-    timeframe_for_freq,
-    NON_FEATURE_COLUMNS,
-)
-
-DEFAULT_INFER_PROCESSORS = [
-    {"class": "DropAllNaN", "kwargs": {}},
-    {"class": "ProcessInf", "kwargs": {}},
-    {"class": "ZScoreNorm", "kwargs": {}},
-    {"class": "Fillna", "kwargs": {}},
-]
-DEFAULT_LEARN_PROCESSORS = [
-    {"class": "DropnaLabel"},
-    {"class": "CSZScoreNorm", "kwargs": {"fields_group": "label"}},
-]
-
-#: always include raw OHLCV; ta-lib columns are discovered from the lake and appended.
-RAW_FEATURE_FIELDS = ("$open", "$high", "$low", "$close", "$vwap", "$volume")
-
-DEFAULT_LABEL = "Ref($close,-2)/Ref($close,-1)-1"
-
-
-def check_transform_proc(proc_l, fit_start_time, fit_end_time):
-    """Port of ``qlib.contrib.data.handler.check_transform_proc`` (inject fit window into procs)."""
-    new_l = []
-    for p in proc_l:
-        if not isinstance(p, processor_module.Processor):
-            klass, pkwargs = get_callable_kwargs(p, processor_module)
-            args = getfullargspec(klass).args
-            if "fit_start_time" in args and "fit_end_time" in args:
-                assert fit_start_time is not None and fit_end_time is not None, (
-                    "Make sure `fit_start_time` and `fit_end_time` are not None."
-                )
-                pkwargs.update({"fit_start_time": fit_start_time, "fit_end_time": fit_end_time})
-            proc_config = {"class": klass.__name__, "kwargs": pkwargs}
-            if isinstance(p, dict) and "module_path" in p:
-                proc_config["module_path"] = p["module_path"]
-            new_l.append(proc_config)
-        else:
-            new_l.append(p)
-    return new_l
-
-
-def get_common_feature_fields(lake_root=None, market="US", timeframe="1d") -> List[str]:
-    """Discover feature columns present in *every* feature file of the lake.
-
-    Walks the `family=ta|sp` partition layout (plus any legacy flat files).
-    TA and SP columns are disjoint by construction, so the common set is
-    computed per family (columns shared by all symbol files of that family),
-    then the per-family results are unioned. Returns sorted field names
-    (without the ``$`` prefix). Empty if no features are persisted.
-    """
-    cfg = LakeConfig(lake_root, market)
-    feat_dir = cfg.features_dir(timeframe)
-    if not feat_dir.exists():
-        return []
-    import pyarrow.parquet as pq
-
-    def _family_common(fam_dir: Path) -> set:
-        common = None
-        for p in sorted(fam_dir.glob("symbol=*.parquet")):
-            try:
-                cols = set(pq.read_schema(p).names) - set(NON_FEATURE_COLUMNS)
-            except Exception:  # pragma: no cover - skip unreadable files
-                continue
-            common = cols if common is None else (common & cols)
-            if not common:
-                break
-        return common or set()
-
-    common: set = set()
-    # family tier: features/market=*/timeframe=*/family=*/symbol=*.parquet
-    for fam in ("ta", "sp"):
-        fam_dir = feat_dir / f"family={fam}"
-        if fam_dir.is_dir():
-            common |= _family_common(fam_dir)
-    # legacy flat: features/market=*/timeframe=*/symbol=*.parquet
-    if (feat_dir / "family=ta").exists() or (feat_dir / "family=sp").exists():
-        pass  # family layout already covered
-    else:
-        common |= _family_common(feat_dir)
-    return sorted(common)
-
-
-class DropAllNaN(processor_module.Processor):
-    """Drop feature columns that are all-NaN over the fit window.
-
-    The lake can hold fully-empty indicator columns (e.g. a ta-lib output that was NaN
-    from the start). Such columns carry no learnable signal and make ``ZScoreNorm.fit``
-    warn on empty slices, so we drop them before any other processor runs. The drop set
-    is fixed on the fit window once (during ``fit``), then applied consistently to every
-    segment so train/valid/test keep identical feature columns.
-    """
-
-    def __init__(self, fit_start_time=None, fit_end_time=None):
-        self.fit_start_time = fit_start_time
-        self.fit_end_time = fit_end_time
-        self.cols_to_drop = []
-
-    def fit(self, df=None):
-        if df is None or len(df) == 0:
-            return self
-        window = df
-        if self.fit_start_time is not None and self.fit_end_time is not None:
-            try:
-                from qlib.data.dataset.utils import fetch_df_by_index
-
-                window = fetch_df_by_index(
-                    df, slice(self.fit_start_time, self.fit_end_time), level="datetime"
-                )
-            except Exception:  # pragma: no cover - defensive
-                window = df
-        if len(window) == 0:
-            return self
-        self.cols_to_drop = [c for c in window.columns if window[c].isna().all()]
-        return self
-
-    def __call__(self, df):
-        if self.cols_to_drop:
-            return df.drop(columns=self.cols_to_drop, errors="ignore")
-        return df
-
-
-class TACHandler(DataHandlerLP):
-    """DataHandlerLP backed by the TradeAC parquet lake.
-
-    Parameters mirror ``Alpha158``: ``instruments``/``start_time``/``end_time``/``freq`` define
-    the queried window; ``feature_fields`` selects the features (default: raw OHLCV + all common
-    ta-lib columns found in the lake); ``label`` is a qlib expression for the target.
-    """
-
-    def __init__(
-        self,
-        instruments="all",
-        start_time=None,
-        end_time=None,
-        freq="day",
-        infer_processors=DEFAULT_INFER_PROCESSORS,
-        learn_processors=DEFAULT_LEARN_PROCESSORS,
-        fit_start_time=None,
-        fit_end_time=None,
-        process_type=DataHandlerLP.PTYPE_A,
-        filter_pipe=None,
-        feature_fields=None,
-        label=DEFAULT_LABEL,
-        lake_root=None,
-        market="US",
-        **kwargs,
-    ):
-        # default the processor fit window to the queried window (like Alpha158 without a split)
-        if fit_start_time is None:
-            fit_start_time = start_time
-        if fit_end_time is None:
-            fit_end_time = end_time
-
-        infer_processors = check_transform_proc(infer_processors, fit_start_time, fit_end_time)
-        learn_processors = check_transform_proc(learn_processors, fit_start_time, fit_end_time)
-
-        feature_fields = self._normalize_feature_fields(feature_fields, freq, lake_root, market)
-        if not feature_fields:
-            raise ValueError(
-                "no feature fields available for the lake; set `feature_fields` explicitly "
-                "(e.g. ['$close', '$rsi_14', '$sma_20'])"
-            )
-
-        label_expr, label_names = self._normalize_label(label)
-
-        data_loader = {
-            "class": "QlibDataLoader",
-            "kwargs": {
-                "config": {
-                    "feature": (feature_fields, feature_fields),
-                    "label": (label_expr, label_names),
-                },
-                "filter_pipe": filter_pipe,
-                "freq": freq,
-            },
-        }
-        super().__init__(
-            instruments=instruments,
-            start_time=start_time,
-            end_time=end_time,
-            data_loader=data_loader,
-            infer_processors=infer_processors,
-            learn_processors=learn_processors,
-            process_type=process_type,
-            **kwargs,
-        )
-
-    # ------------------------------------------------------------------ config
-    @staticmethod
-    def _normalize_feature_fields(feature_fields, freq, lake_root, market) -> List[str]:
-        if feature_fields is None:
-            common = get_common_feature_fields(lake_root, market, timeframe_for_freq(freq))
-            feature_fields = list(RAW_FEATURE_FIELDS) + ["$" + f for f in common if "$" + f not in RAW_FEATURE_FIELDS]
-        elif isinstance(feature_fields, str):
-            feature_fields = [f.strip() for f in feature_fields.split(",") if f.strip()]
-        fields = [f if f.startswith("$") else "$" + f for f in feature_fields]
-        # de-dup while preserving order
-        seen, out = set(), []
-        for f in fields:
-            if f not in seen:
-                seen.add(f)
-                out.append(f)
-        return out
-
-    @staticmethod
-    def _normalize_label(label) -> Tuple[List[str], List[str]]:
-        if isinstance(label, str):
-            return [label], ["LABEL0"]
-        if isinstance(label, (list, tuple)):
-            if len(label) == 2 and isinstance(label[0], str):
-                return [label[0]], list(label[1]) if isinstance(label[1], (list, tuple)) else [label[1]]
-            return list(label), ["LABEL%d" % i for i in range(len(label))]
-        raise TypeError(f"unsupported label config: {label!r}")
-
-    # ------------------------------------------------------------------ utils
-    def get_label_config(self):
-        return DEFAULT_LABEL
-
-    @staticmethod
-    def discover_feature_fields(lake_root=None, market="US", freq="day") -> List[str]:
-        return get_common_feature_fields(lake_root, market, timeframe_for_freq(freq))
-
-
-__all__ = ["TACHandler", "DropAllNaN", "get_common_feature_fields"]
-
-
-# Make `DropAllNaN` resolvable by bare name from processor configs (e.g. the default
-# ``infer_processors`` and workflow yamls that reference it without a ``module_path``),
-# mirroring how qlib registers its own processors in ``qlib.data.dataset.processor``.
-processor_module.DropAllNaN = DropAllNaN

code/tac-qlib/tac_qlib/contrib/model/__init__.py

@@ -1,4 +0,0 @@
-from .rank_ensemble import RankICEnsembleLGBModel  # noqa: F401
-from .rank_gbdt import RankICLGBModel, rankic_feval  # noqa: F401
-
-__all__ = ["RankICLGBModel", "rankic_feval", "RankICEnsembleLGBModel"]

code/tac-qlib/tac_qlib/contrib/model/rank_ensemble.py

@@ -1,189 +0,0 @@
-"""Seed-ensembled LightGBM that early-stops on cross-sectional RankIC.
-
-``RankICEnsembleLGBModel`` wraps ``RankICLGBModel`` (per-day RankIC feval +
-``metric='None'`` + ``first_metric_only`` early stopping) over a seed ensemble:
-one sub-model is trained per seed with identical hyper-parameters, and
-predictions are averaged across seeds. This is the model class the
-``tac-rd-rank-ensemble-isolated`` reference run wires into its workflow
-(``module_path: tac_qlib.contrib.model.rank_ensemble``).
-
-The ensemble inherits the RankIC early-stopping behaviour of the single-seed
-model (valid RankIC drives the stopping iteration) while the seed averaging
-stabilizes the prediction against any single seed's early-stopping path.
-
-Training is parallelized: the seed sub-models train in a thread pool —
-``lgb.train`` is C++ and releases the GIL, so concurrent seeds do not block on
-the GIL (5 seeds ~40min/5 on this box). Measured on a 6-physical-core / 12 SMT
-host: the seeds scale ~2x, not linearly — the runs are memory-bandwidth bound
-and each Booster caps its threads at ``cores // workers`` so 5 concurrent
-boosters don't oversubscribe; larger-core hosts scale better. The qlib data
-pipeline is warmed once on the calling thread (fills the handler cache), and
-each worker then prepares its **own** ``lgb.Dataset`` (independent handle, so
-no concurrent ``construct()`` on a shared handle — LightGBM's ``Dataset`` is
-not thread-safe to build). qlib's ``R`` recorder is also not thread-safe, so
-the per-seed evaluation curves are logged on the calling thread after the pool
-finishes.
-
-Wired into a workflow yaml like:
-
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-Any ``**kwargs`` other than ``seeds``/``parallel`` are forwarded unchanged to
-every ``RankICLGBModel`` sub-model (same params, different ``seed``).
-"""
-
-from __future__ import annotations
-
-import os
-from concurrent.futures import ThreadPoolExecutor
-from typing import List, Optional
-
-import pandas as pd
-
-from qlib.data.dataset import DatasetH
-from qlib.data.dataset.handler import DataHandlerLP
-
-from tac_qlib.contrib.model.rank_gbdt import RankICLGBModel
-
-__all__ = ["RankICEnsembleLGBModel"]
-
-
-class RankICEnsembleLGBModel(RankICLGBModel):
-    """Seed ensemble of RankIC-early-stopping LightGBM models.
-
-    Parameters
-    ----------
-    seeds : comma-separated integers, one sub-model per seed.
-    parallel : number of seeds to train concurrently. ``0`` (default) = auto
-        (all seeds, bounded by the available cores); ``1`` = sequential.
-    **kwargs : forwarded to every ``RankICLGBModel`` sub-model (model
-        hyper-parameters). ``seeds``/``parallel`` are consumed here and not
-        forwarded.
-    """
-
-    def __init__(self, seeds: str = "42", parallel: int = 0, **kwargs):
-        self.seeds = [int(s.strip()) for s in str(seeds).split(",") if s.strip()]
-        if not self.seeds:
-            raise ValueError("seeds must contain at least one integer")
-        self.parallel = int(parallel)
-        # drop seed/parallel handling from the base kwargs, keep everything else
-        self._model_kwargs = dict(kwargs)
-        super().__init__(**self._model_kwargs)
-        self._models: List[RankICLGBModel] = []
-
-    # --------------------------------------------------------------- helpers
-    @staticmethod
-    def _cores() -> int:
-        try:
-            return max(1, len(os.sched_getaffinity(0)))
-        except AttributeError:
-            return max(1, os.cpu_count() or 1)
-
-    def _worker_count(self) -> int:
-        if self.parallel > 0:
-            return min(len(self.seeds), self.parallel)
-        return min(len(self.seeds), self._cores())
-
-    # ------------------------------------------------------------------ fit
-    def fit(
-        self,
-        dataset: DatasetH,
-        num_boost_round: Optional[int] = None,
-        early_stopping_rounds: Optional[int] = None,
-        verbose_eval: int = 20,
-        evals_result=None,
-        reweighter=None,
-        **kwargs,
-    ):
-        """Train one RankICLGBModel per seed and keep them for prediction.
-
-        The qlib data pipeline is warmed once on this thread (handler cache),
-        then each seed sub-model trains in a parallel worker thread on its own
-        ``lgb.Dataset`` (LightGBM releases the GIL in ``lgb.train``). Evals
-        are logged on this thread after the pool (qlib's ``R`` is not
-        thread-safe).
-        """
-        n_round = num_boost_round or self.num_boost_round
-        n_es = early_stopping_rounds or self.early_stopping_rounds
-
-        if len(self.seeds) == 1:
-            m = RankICLGBModel(seed=self.seeds[0], **self._model_kwargs)
-            m.fit(
-                dataset,
-                num_boost_round=n_round,
-                early_stopping_rounds=n_es,
-                verbose_eval=verbose_eval,
-                evals_result=evals_result,
-                reweighter=reweighter,
-                **kwargs,
-            )
-            self._models = [m]
-            return
-
-        # Warm the qlib handler cache once on this thread so the workers'
-        # concurrent prepare() calls only hit cached frames (no first-write race).
-        proto = RankICLGBModel(seed=self.seeds[0], **self._model_kwargs)
-        proto._prepare_data(dataset, reweighter)
-
-        workers = self._worker_count()
-        # Cap per-Booster threads so concurrent seeds don't oversubscribe
-        # (LightGBM's num_threads=0 uses ALL cores per Booster).
-        per_booster = max(1, self._cores() // workers)
-
-        def fit_seed(seed):
-            m = RankICLGBModel(seed=seed, **self._model_kwargs)
-            if workers > 1 and "num_threads" not in m.params:
-                m.params["num_threads"] = per_booster
-            ds_l = m._prepare_data(dataset, reweighter)
-            booster, evals, names = m._train_from_datasets(
-                ds_l,
-                num_boost_round=n_round,
-                early_stopping_rounds=n_es,
-                verbose_eval=verbose_eval,
-                **kwargs,
-            )
-            m.model = booster
-            return m, evals, names
-
-        with ThreadPoolExecutor(max_workers=workers) as ex:
-            results = list(ex.map(fit_seed, self.seeds))
-
-        self._models = [m for m, _, _ in results]
-
-        # Merge + log evals on the main thread (qlib's R is not thread-safe).
-        if evals_result is not None:
-            for m, evals, names in results:
-                for k in names:
-                    for key, val in evals.get(k, {}).items():
-                        evals_result.setdefault(f"{k}.seed{m.params['seed']}", {})[key] = val
-        for m, evals, names in results:
-            self._log_evals(evals, names, prefix=f"seed{m.params['seed']}.")
-
-    # -------------------------------------------------------------- predict
-    def predict(self, dataset: DatasetH, segment="test") -> pd.Series:
-        """Average the per-seed predictions over the given segment."""
-        if not self._models:
-            raise ValueError("model is not fitted yet!")
-        preds = [m.predict(dataset, segment=segment) for m in self._models]
-        if len(preds) == 1:
-            return preds[0]
-        frame = pd.concat(preds, axis=1)
-        return frame.mean(axis=1)

code/tac-qlib/tac_qlib/contrib/model/rank_gbdt.py

@@ -1,238 +0,0 @@
-"""LGBModel variant that early-stops on cross-sectional RankIC instead of l2.
-
-Standard qlib ``LGBModel`` early-stops on the regression loss (mse). For
-cross-sectional alpha signals the quantity we actually care about is the per-day
-rank correlation (Rank IC), which mse early-stopping does not optimize for.
-Experiments on the 50-ETF lake (SP-5d 55-feature panel) show that early-stopping
-on a custom RankIC feval lifts RankIC 0.047 -> 0.075 vs. the mse-stopped model.
-
-This class reuses ``LGBModel``'s data preparation but:
-
-  - tags each ``lgb.Dataset`` with per-day query ``group`` sizes so a ranking
-    metric can be computed per trading day;
-  - injects a custom ``feval`` (mean per-day Spearman of pred vs label) into
-    ``lgb.train``; early stopping then selects the iteration that maximizes
-    RankIC on the valid set;
-  - forces ``metric='None'`` + ``first_metric_only=True`` so early-stopping
-    tracks RankIC only (not the regression loss).
-
-Wired into a workflow yaml like:
-
-    model:
-        class: RankICLGBModel
-        module_path: tac_qlib.contrib.model.rank_gbdt
-        kwargs:
-            loss: mse
-            learning_rate: 0.03
-            num_leaves: 31
-            n_estimators: 500
-            ...
-
-The rank feval is used for early-stopping selection only; the objective stays
-the configured loss (default mse). Set ``rank_eval=False`` to fall back to the
-plain LGBModel behaviour (early-stop on the loss).
-
-Generic: works for any cross-sectional panel whose qlib dataset index has a
-``datetime`` level (each level value = one query group). The per-day groups are
-derived automatically, so no universe-specific configuration is needed.
-"""
-
-from __future__ import annotations
-
-from typing import List, Optional, Tuple
-
-import numpy as np
-import pandas as pd
-import lightgbm as lgb
-
-from qlib.data.dataset import DatasetH
-from qlib.data.dataset.handler import DataHandlerLP
-from qlib.contrib.model.gbdt import LGBModel
-from qlib.workflow import R
-
-__all__ = ["RankICLGBModel", "rankic_feval"]
-
-
-def _group_averaged_rank(values: np.ndarray, gid: np.ndarray, offs: np.ndarray) -> np.ndarray:
-    """Averaged (tie-corrected) rank of ``values`` within each group, vectorized.
-
-    ``gid`` maps each row to its group id; ``offs`` holds the cumulative row
-    offsets so that group ``i`` occupies rows ``[offs[i], offs[i+1])``. Returns
-    the same result as ``pandas.Series.rank(method='average')`` applied per
-    group, but in one pass (``np.lexsort`` is the only non-linear step).
-    """
-    n = len(values)
-    order = np.lexsort((values, gid))
-    ord_rank = np.empty(n, dtype=np.float64)
-    ord_rank[order] = np.arange(n, dtype=np.float64) - offs[gid[order]] + 1.0
-    sg = gid[order]
-    sv = values[order]
-    newblock = np.empty(n, dtype=bool)
-    newblock[0] = True
-    newblock[1:] = (sg[1:] != sg[:-1]) | (sv[1:] != sv[:-1])
-    blockid = np.cumsum(newblock) - 1
-    block_mean = np.bincount(blockid, weights=ord_rank[order]) / np.bincount(blockid)
-    out = np.empty(n)
-    out[order] = block_mean[blockid]
-    return out
-
-
-def _per_day_spearman(preds: np.ndarray, labels: np.ndarray, group: np.ndarray) -> float:
-    """Mean per-day Spearman rank correlation of preds vs labels.
-
-    ``group`` holds the number of rows of each trading day (query group), in
-    order. Days with <3 valid rows or a constant pred/label are skipped.
-
-    Vectorized: per-day Spearman == Pearson of the per-day rank transforms,
-    and the Pearson moments (``sum``, ``sum`` of products/squares) aggregate
-    over each day with ``np.bincount``. Runs ~10x faster than the per-day
-    ``pd.Series.rank()`` loop that preceded it — this feval is invoked on the
-    train and valid panels every boosting round, per seed.
-    """
-    if group is None or len(group) == 0:
-        return 0.0
-    offs = np.concatenate([[0], np.cumsum(group.astype(int))])
-    gid = np.repeat(np.arange(len(group)), group.astype(int))
-    rp = _group_averaged_rank(preds, gid, offs)
-    rl = _group_averaged_rank(labels, gid, offs)
-    n_g = group.astype(float)
-    s_p = np.bincount(gid, weights=rp)
-    s_l = np.bincount(gid, weights=rl)
-    s_pl = np.bincount(gid, weights=rp * rl)
-    s_pp = np.bincount(gid, weights=rp * rp)
-    s_ll = np.bincount(gid, weights=rl * rl)
-    cov = n_g * s_pl - s_p * s_l
-    var_p = n_g * s_pp - s_p ** 2
-    var_l = n_g * s_ll - s_l ** 2
-    denom = np.sqrt(var_p * var_l)
-    valid = (n_g >= 3) & (denom > 0)
-    corr = np.where(valid, cov / np.where(denom == 0, 1, denom), 0.0)
-    return float(corr[valid].mean()) if valid.any() else 0.0
-
-
-def rankic_feval(preds, dataset):
-    """LightGBM feval: mean RankIC (higher is better in lgb convention)."""
-    labels = dataset.get_label()
-    group = dataset.get_group()
-    ric = _per_day_spearman(preds, labels, group)
-    return "rankic", ric, True  # (name, value, higher_is_better)
-
-
-class RankICLGBModel(LGBModel):
-    """LGBModel that early-stops on per-day RankIC via a custom feval."""
-
-    def __init__(self, rank_eval: bool = True, **kwargs):
-        super().__init__(**kwargs)
-        self.rank_eval = rank_eval
-
-    def _prepare_data(self, dataset: DatasetH, reweighter=None) -> List[Tuple[lgb.Dataset, str]]:
-        ds_l = []
-        assert "train" in dataset.segments
-        for key in ["train", "valid"]:
-            if key in dataset.segments:
-                df = dataset.prepare(key, col_set=["feature", "label"], data_key=DataHandlerLP.DK_L)
-                if df.empty:
-                    raise ValueError("Empty data from dataset, please check your dataset config.")
-                x, y = df["feature"], df["label"]
-                if y.values.ndim == 2 and y.values.shape[1] == 1:
-                    y = np.squeeze(y.values)
-                else:
-                    raise ValueError("LightGBM doesn't support multi-label training")
-
-                if reweighter is None:
-                    w = None
-                elif hasattr(reweighter, "reweight"):
-                    w = reweighter.reweight(df)
-                else:
-                    raise ValueError("Unsupported reweighter type.")
-
-                # per-day query groups: each trading day is one group
-                if self.rank_eval and isinstance(df.index, pd.MultiIndex) and "datetime" in df.index.names:
-                    group = df.groupby(level="datetime").size().to_numpy(dtype=np.int32)
-                else:
-                    group = None
-
-                d = lgb.Dataset(x.values, label=y, weight=w, group=group, free_raw_data=False)
-                ds_l.append((d, key))
-        return ds_l
-
-    def _train_from_datasets(
-        self,
-        ds_l: List[Tuple[lgb.Dataset, str]],
-        num_boost_round: Optional[int] = None,
-        early_stopping_rounds: Optional[int] = None,
-        verbose_eval: int = 20,
-        evals_result=None,
-        **kwargs,
-    ) -> Tuple[lgb.Booster, dict, List[str]]:
-        """Train a Booster from already-prepared ``lgb.Dataset`` objects.
-
-        Pure training — no ``R.log_metrics`` — so it can be called from worker
-        threads (qlib's ``R`` recorder is not thread-safe; the caller decides
-        when/where to log). Returns ``(booster, evals_result, segment_names)``.
-        """
-        if evals_result is None:
-            evals_result = {}
-        ds, names = list(zip(*ds_l))
-
-        callbacks = [
-            lgb.early_stopping(
-                self.early_stopping_rounds if early_stopping_rounds is None else early_stopping_rounds
-            ),
-            lgb.log_evaluation(period=verbose_eval),
-            lgb.record_evaluation(evals_result),
-        ]
-        if self.rank_eval:
-            # early-stopping must be driven ONLY by the RankIC feval, not l2.
-            # metric='None' suppresses the default l2 metric; first_metric_only
-            # makes early_stopping track the single remaining (rankic) metric.
-            self.params["metric"] = "None"
-            self.params["first_metric_only"] = True
-            feval = rankic_feval
-        else:
-            self.params.pop("metric", None)
-            self.params.pop("first_metric_only", None)
-            feval = None
-
-        booster = lgb.train(
-            self.params,
-            ds[0],
-            num_boost_round=self.num_boost_round if num_boost_round is None else num_boost_round,
-            valid_sets=ds,
-            valid_names=names,
-            feval=feval,
-            callbacks=callbacks,
-            **kwargs,
-        )
-        return booster, evals_result, list(names)
-
-    def _log_evals(self, evals_result, names: List[str], prefix: str = "") -> None:
-        """Log recorded evaluation curves to qlib's active recorder."""
-        for k in names:
-            for key, val in evals_result.get(k, {}).items():
-                name = f"{prefix}{key}.{k}"
-                for epoch, m in enumerate(val):
-                    R.log_metrics(**{name.replace("@", "_"): m}, step=epoch)
-
-    def fit(
-        self,
-        dataset: DatasetH,
-        num_boost_round: Optional[int] = None,
-        early_stopping_rounds: Optional[int] = None,
-        verbose_eval: int = 20,
-        evals_result=None,
-        reweighter=None,
-        **kwargs,
-    ):
-        if evals_result is None:
-            evals_result = {}
-        ds_l = self._prepare_data(dataset, reweighter)
-        self.model, evals_result, names = self._train_from_datasets(
-            ds_l,
-            num_boost_round=num_boost_round,
-            early_stopping_rounds=early_stopping_rounds,
-            verbose_eval=verbose_eval,
-            evals_result=evals_result,
-            **kwargs,
-        )
-        self._log_evals(evals_result, names)

code/tac-qlib/tac_qlib/contrib/strategy/__init__.py

@@ -1,13 +0,0 @@
-from .kelly_dropout import FractionalKellyDropoutStrategy  # noqa: F401
-from .optimal_stop import OptimalStopControl  # noqa: F401
-from .regime_gate import RegimeGateDropoutStrategy  # noqa: F401
-from .top_bottom import TopBottomDropoutStrategy  # noqa: F401
-from .weekly_rebalance import WeeklyRebalanceDropoutStrategy  # noqa: F401
-
-__all__ = [
-    "OptimalStopControl",
-    "FractionalKellyDropoutStrategy",
-    "WeeklyRebalanceDropoutStrategy",
-    "TopBottomDropoutStrategy",
-    "RegimeGateDropoutStrategy",
-]

code/tac-qlib/tac_qlib/contrib/strategy/kelly_dropout.py

@@ -1,201 +0,0 @@
-"""Fractional-Kelly dropout strategy for cross-sectional signals.
-
-Sizing rule variant of ``qlib.contrib.strategy.signal_strategy.TopkDropoutStrategy``:
-the topk/n_drop SELECTION is identical to the reference, but the buy size is
-proportional to the score MAGNITUDE (edge) instead of equal-weight, capped at a
-fraction ``cap_frac`` of the equal-weight notional so a single name cannot
-over-concentrate the book.
-
-``cap_frac`` is the fraction of the equal-weight per-name notional that a top
-signal can deploy at most (e.g. 0.5 = at most half the equal-weight size).
-Names whose score is below the median of the buy set get a proportionally
-smaller slice; the residual stays in cash (that is the point of the rule:
-throw away less edge per name, deploy less capital when conviction is low).
-"""
-
-from __future__ import annotations
-
-from typing import List
-
-import numpy as np
-import pandas as pd
-
-from qlib.backtest import Order
-from qlib.backtest.decision import OrderDir, TradeDecisionWO
-from qlib.contrib.strategy.signal_strategy import TopkDropoutStrategy
-
-__all__ = ["FractionalKellyDropoutStrategy"]
-
-DEFAULT_CAP_FRAC = 0.5
-
-
-class FractionalKellyDropoutStrategy(TopkDropoutStrategy):
-    """TopkDropout selection with score-magnitude (fractional-Kelly) sizing.
-
-    Parameters
-    ----------
-    topk, n_drop, method_sell, method_buy, hold_thresh, only_tradable,
-    forbid_all_trade_at_limit : same as ``TopkDropoutStrategy``.
-    cap_frac : max buy notional as a fraction of the equal-weight notional.
-    """
-
-    def __init__(self, *, topk, n_drop, cap_frac: float = DEFAULT_CAP_FRAC, **kwargs):
-        super().__init__(topk=topk, n_drop=n_drop, **kwargs)
-        self.cap_frac = cap_frac
-
-    def generate_trade_decision(self, execute_result=None):
-        import copy
-
-        trade_step = self.trade_calendar.get_trade_step()
-        trade_start_time, trade_end_time = self.trade_calendar.get_step_time(trade_step)
-        pred_start_time, pred_end_time = self.trade_calendar.get_step_time(trade_step, shift=1)
-        pred_score = self.signal.get_signal(start_time=pred_start_time, end_time=pred_end_time)
-        if isinstance(pred_score, pd.DataFrame):
-            pred_score = pred_score.iloc[:, 0]
-        if pred_score is None:
-            return TradeDecisionWO([], self)
-
-        if self.only_tradable:
-
-            def get_first_n(li, n, reverse=False):
-                cur_n = 0
-                res = []
-                for si in reversed(li) if reverse else li:
-                    if self.trade_exchange.is_stock_tradable(
-                        stock_id=si, start_time=trade_start_time, end_time=trade_end_time
-                    ):
-                        res.append(si)
-                        cur_n += 1
-                        if cur_n >= n:
-                            break
-                return res[::-1] if reverse else res
-
-            def get_last_n(li, n):
-                return get_first_n(li, n, reverse=True)
-
-            def filter_stock(li):
-                return [
-                    si
-                    for si in li
-                    if self.trade_exchange.is_stock_tradable(
-                        stock_id=si, start_time=trade_start_time, end_time=trade_end_time
-                    )
-                ]
-
-        else:
-
-            def get_first_n(li, n):
-                return list(li)[:n]
-
-            def get_last_n(li, n):
-                return list(li)[-n:]
-
-            def filter_stock(li):
-                return li
-
-        current_temp: "object" = copy.deepcopy(self.trade_position)
-        sell_order_list: List[Order] = []
-        buy_order_list: List[Order] = []
-        cash = current_temp.get_cash()
-        current_stock_list = current_temp.get_stock_list()
-        last = pred_score.reindex(current_stock_list).sort_values(ascending=False).index
-
-        if self.method_buy == "top":
-            today = get_first_n(
-                pred_score[~pred_score.index.isin(last)].sort_values(ascending=False).index,
-                self.n_drop + self.topk - len(last),
-            )
-        elif self.method_buy == "random":
-            topk_candi = get_first_n(pred_score.sort_values(ascending=False).index, self.topk)
-            candi = list(filter(lambda x: x not in last, topk_candi))
-            n = self.n_drop + self.topk - len(last)
-            try:
-                today = np.random.choice(candi, n, replace=False)
-            except ValueError:
-                today = candi
-        else:
-            raise NotImplementedError(f"This type of input is not supported")
-
-        comb = pred_score.reindex(last.union(pd.Index(today))).sort_values(ascending=False).index
-
-        if self.method_sell == "bottom":
-            sell = last[last.isin(get_last_n(comb, self.n_drop))]
-        elif self.method_sell == "random":
-            candi = filter_stock(last)
-            try:
-                sell = pd.Index(np.random.choice(candi, self.n_drop, replace=False) if len(last) else [])
-            except ValueError:
-                sell = candi
-        else:
-            raise NotImplementedError(f"This type of input is not supported")
-
-        buy = today[: len(sell) + self.topk - len(last)]
-        for code in current_stock_list:
-            if not self.trade_exchange.is_stock_tradable(
-                stock_id=code,
-                start_time=trade_start_time,
-                end_time=trade_end_time,
-                direction=None if self.forbid_all_trade_at_limit else OrderDir.SELL,
-            ):
-                continue
-            if code in sell:
-                time_per_step = self.trade_calendar.get_freq()
-                if current_temp.get_stock_count(code, bar=time_per_step) < self.hold_thresh:
-                    continue
-                sell_amount = current_temp.get_stock_amount(code=code)
-                sell_order = Order(
-                    stock_id=code,
-                    amount=sell_amount,
-                    start_time=trade_start_time,
-                    end_time=trade_end_time,
-                    direction=Order.SELL,
-                )
-                if self.trade_exchange.check_order(sell_order):
-                    sell_order_list.append(sell_order)
-                    trade_val, trade_cost, trade_price = self.trade_exchange.deal_order(
-                        sell_order, position=current_temp
-                    )
-                    cash += trade_val - trade_cost
-
-        if len(buy) == 0:
-            return TradeDecisionWO(sell_order_list, self)
-
-        # ---- fractional-Kelly sizing --------------------------------------
-        # equal-weight notional (reference baseline)
-        eq_notional = cash * self.risk_degree / len(buy)
-        buy_scores = pred_score.reindex(buy).astype(float)
-        lo, hi = buy_scores.min(), buy_scores.max()
-        if hi == lo:
-            w = pd.Series(1.0, index=buy_scores.index)
-        else:
-            w = (buy_scores - lo) / (hi - lo)  # [0,1] edge magnitude
-            w = w.clip(lower=0.0)
-            w_max = w.max()
-            w = w / w_max if w_max > 0 else w  # max == 1.0
-        for code in buy:
-            if not self.trade_exchange.is_stock_tradable(
-                stock_id=code,
-                start_time=trade_start_time,
-                end_time=trade_end_time,
-                direction=None if self.forbid_all_trade_at_limit else OrderDir.BUY,
-            ):
-                continue
-            buy_price = self.trade_exchange.get_deal_price(
-                stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=OrderDir.BUY
-            )
-            notional = eq_notional * min(self.cap_frac, float(w.get(code, 0.0)))
-            buy_amount = notional / buy_price
-            factor = self.trade_exchange.get_factor(
-                stock_id=code, start_time=trade_start_time, end_time=trade_end_time
-            )
-            buy_amount = self.trade_exchange.round_amount_by_trade_unit(buy_amount, factor)
-            buy_order = Order(
-                stock_id=code,
-                amount=buy_amount,
-                start_time=trade_start_time,
-                end_time=trade_end_time,
-                direction=Order.BUY,
-            )
-            buy_order_list.append(buy_order)
-
-        return TradeDecisionWO(sell_order_list + buy_order_list, self)

code/tac-qlib/tac_qlib/contrib/strategy/optimal_stop.py

@@ -1,217 +0,0 @@
-"""Optimal-stopping / stochastic-control strategy for cross-sectional signals.
-
-Entry is a control policy: a symbol opens a position only when its cross-sectional
-signal percentile is at or above ``entry_pct`` (i.e. it is one of the top-ranked
-names) and the portfolio has fewer than ``topk`` open positions.
-
-Exit is an optimal-stopping rule: a held position is stopped (closed) when its
-signal percentile falls below ``exit_pct`` (the continuation value of holding is
-no longer worth the risk), OR after ``max_hold_days`` (time stop / finite
-horizon), OR when the position P&L breaches ``sl`` (loss control) and the
-position has been held at least ``min_hold_days``.
-
-Sizing is fixed ``notional`` per position (equal-weight control), unlike the
-TopkDropout cash-allocation heuristic.
-
-Wired into qrun workflows like any ``BaseStrategy`` (see ``PortAnaRecord``
-config). Mirrors the API usage of qlib's ``TopkDropoutStrategy``: ``Order``/
-``OrderDir`` from ``qlib.backtest.decision``, ``trade_calendar`` /
-``trade_exchange`` / ``trade_position`` injected by the backtest executor.
-"""
-
-from __future__ import annotations
-
-from typing import List
-
-import pandas as pd
-
-from qlib.backtest import Order
-from qlib.backtest.decision import OrderDir, TradeDecisionWO
-from qlib.contrib.strategy.signal_strategy import BaseSignalStrategy
-
-__all__ = ["OptimalStopControl"]
-
-DEFAULT_NOTIONAL = 20_000.0
-DEFAULT_ENTRY_PCT = 0.80
-DEFAULT_EXIT_PCT = 0.50
-DEFAULT_MAX_HOLD_DAYS = 10
-DEFAULT_MIN_HOLD_DAYS = 2
-DEFAULT_SL = -0.06
-
-
-class OptimalStopControl(BaseSignalStrategy):
-    """Optimal-stopping long-only strategy over a cross-sectional signal.
-
-    Parameters
-    ----------
-    topk : max number of concurrent positions.
-    entry_pct : min cross-sectional score percentile required to OPEN (0..1).
-    exit_pct : held positions are stopped when score percentile < exit_pct.
-    max_hold_days : hard time stop (finite-horizon close).
-    min_hold_days : minimum holding days before stop-loss is evaluated.
-    notional : $ per position (equal-weight control).
-    sl : stop-loss threshold as fraction of entry price (<= 0), disabled if 0.
-    """
-
-    def __init__(
-        self,
-        *,
-        signal=None,
-        topk: int = 10,
-        entry_pct: float = DEFAULT_ENTRY_PCT,
-        exit_pct: float = DEFAULT_EXIT_PCT,
-        max_hold_days: int = DEFAULT_MAX_HOLD_DAYS,
-        min_hold_days: int = DEFAULT_MIN_HOLD_DAYS,
-        notional: float = DEFAULT_NOTIONAL,
-        sl: float = DEFAULT_SL,
-        risk_degree: float = 0.95,
-        trade_exchange=None,
-        level_infra=None,
-        common_infra=None,
-        **kwargs,
-    ):
-        super().__init__(
-            signal=signal,
-            trade_exchange=trade_exchange,
-            level_infra=level_infra,
-            common_infra=common_infra,
-            **kwargs,
-        )
-        self.topk = topk
-        self.entry_pct = entry_pct
-        self.exit_pct = exit_pct
-        self.max_hold_days = max_hold_days
-        self.min_hold_days = min_hold_days
-        self.notional = notional
-        self.sl = sl
-
-    # ------------------------------------------------------------------ utils
-    @staticmethod
-    def _pct_rank(score: pd.Series) -> pd.Series:
-        return score.rank(pct=True)
-
-    def _entry_price(self, pos) -> float:
-        # Position stores avg entry price under key "price" (see Position.position)
-        price = pos.position.get("price")
-        if price is None:
-            price = pos.get_stock_amount("price")
-        return float(price)
-
-    def _pnl_pct(self, pos, mark: float) -> float:
-        entry = self._entry_price(pos)
-        if not entry or entry != entry:
-            return 0.0
-        return mark / entry - 1.0
-
-    def _is_tradable(self, code, start, end, direction) -> bool:
-        try:
-            return self.trade_exchange.is_stock_tradable(
-                stock_id=code, start_time=start, end_time=end, direction=direction
-            )
-        except TypeError:  # some exchanges take no direction kwarg
-            return self.trade_exchange.is_stock_tradable(stock_id=code, start_time=start, end_time=end)
-
-    # ------------------------------------------------------------ decision
-    def generate_trade_decision(self, execute_result=None):
-        trade_step = self.trade_calendar.get_trade_step()
-        trade_start, trade_end = self.trade_calendar.get_step_time(trade_step)
-        pred_start, pred_end = self.trade_calendar.get_step_time(trade_step, shift=1)
-        pred_score = self.signal.get_signal(start_time=pred_start, end_time=pred_end)
-        if isinstance(pred_score, pd.DataFrame):
-            pred_score = pred_score.iloc[:, 0]
-        if pred_score is None or len(pred_score) == 0:
-            return TradeDecisionWO([], self)
-
-        pct = self._pct_rank(pred_score)
-        time_per_step = self.trade_calendar.get_freq()
-        current_temp = __import__("copy").deepcopy(self.trade_position)
-
-        holdings = {}
-        for code in current_temp.get_stock_list():
-            if abs(current_temp.get_stock_amount(code)) > 1e-6:
-                holdings[code] = current_temp
-
-        # ---- optimal stopping: close held positions -----------------------
-        sell_orders: List[Order] = []
-        closed_today = set()
-        kept = {}
-        for code, pos in holdings.items():
-            held = current_temp.get_stock_count(code, bar=time_per_step)
-            mark = self.trade_exchange.get_deal_price(
-                stock_id=code, start_time=trade_start, end_time=trade_end, direction=Order.SELL
-            )
-            if mark is None or mark != mark:
-                continue
-            rank = pct.get(code, 0.0)
-            stop_pnl = held >= self.min_hold_days and self.sl < 0 and self._pnl_pct(pos, mark) <= self.sl
-            if held >= self.max_hold_days or rank < self.exit_pct or stop_pnl:
-                amt = abs(current_temp.get_stock_amount(code))
-                o = Order(stock_id=code, amount=amt, start_time=trade_start,
-                          end_time=trade_end, direction=Order.SELL)
-                if self.trade_exchange.check_order(o):
-                    sell_orders.append(o)
-                    self.trade_exchange.deal_order(o, position=current_temp)
-                closed_today.add(code)
-            else:
-                kept[code] = mark
-
-        # ---- equal-weight control: target notional per name -----------------
-        # candidate opens: top-ranked names whose signal pct >= entry_pct
-        rank_desc = pred_score.sort_values(ascending=False)
-        held_codes = set(kept)
-        opens = []
-        for sym in rank_desc.index:
-            if len(opens) >= self.topk:
-                break
-            if sym in held_codes:
-                continue
-            if pct.get(sym, 0.0) < self.entry_pct:
-                continue
-            if not self._is_tradable(sym, trade_start, trade_end, OrderDir.BUY):
-                continue
-            opens.append(sym)
-
-        targets = held_codes | set(opens)
-        if not targets:
-            return TradeDecisionWO(sell_orders, self)
-
-        # total value (cash + marked positions) -> per-target notional
-        total_value = current_temp.get_cash()
-        for code, mark in kept.items():
-            total_value += abs(current_temp.get_stock_amount(code)) * mark
-
-        target_notional = total_value * self.risk_degree / max(1, len(targets))
-
-        # ---- rebalance kept positions toward target weight ------------------
-        buy_orders: List[Order] = []
-        for code, mark in kept.items():
-            cur = abs(current_temp.get_stock_amount(code)) * mark
-            diff_notional = target_notional - cur
-            if abs(diff_notional) / target_notional < 0.02:
-                continue  # skip tiny rebalances
-            amount_delta = diff_notional / mark
-            direction = Order.BUY if amount_delta > 0 else Order.SELL
-            o = Order(stock_id=code, amount=abs(amount_delta), start_time=trade_start,
-                      end_time=trade_end, direction=direction)
-            if self.trade_exchange.check_order(o):
-                (buy_orders if direction == Order.BUY else sell_orders).append(o)
-                self.trade_exchange.deal_order(o, position=current_temp)
-
-        # ---- open new positions at target weight ----------------------------
-        for sym in opens:
-            px = self.trade_exchange.get_deal_price(
-                stock_id=sym, start_time=trade_start, end_time=trade_end, direction=OrderDir.BUY
-            )
-            if px is None or px != px or px <= 0:
-                continue
-            amount = target_notional / px
-            factor = self.trade_exchange.get_factor(
-                stock_id=sym, start_time=trade_start, end_time=trade_end
-            )
-            amount = self.trade_exchange.round_amount_by_trade_unit(amount, factor)
-            o = Order(stock_id=sym, amount=amount, start_time=trade_start,
-                      end_time=trade_end, direction=Order.BUY)
-            if self.trade_exchange.check_order(o):
-                buy_orders.append(o)
-
-        return TradeDecisionWO(sell_orders + buy_orders, self)

code/tac-qlib/tac_qlib/contrib/strategy/regime_gate.py

@@ -1,231 +0,0 @@
-"""HMM-regime overlay TopkDropout strategy.
-
-Regime-gate overlay on ``qlib.contrib.strategy.signal_strategy.TopkDropoutStrategy``:
-selection and sizing are identical to the reference, but a name is only BOUGHT
-(entry gate) when its per-symbol HMM regime posterior ``sp_hmm_p_regime1`` on
-the signal date is >= ``regime_threshold``; otherwise it is held in cash instead
-of being opened.
-
-The regime posterior is read from the lake feature provider on the fly via
-``qlib.data.D.features`` (field ``$sp_hmm_p_regime1``) for the signal window, so
-no regime column needs to enter the model's ``feature_fields`` — the gate is a
-pure overlay (book ch.01: regime flags regressed as model features, survived
-only as an overlay). The HMM itself was fit with ``fit_end=<train end>`` when
-the lake features were backfilled, so there is no lookahead.
-
-Names already held are NOT force-sold when the regime turns unfavourable
-(entry gate only, matching the queue-10 design).
-"""
-
-from __future__ import annotations
-
-from typing import List
-
-import numpy as np
-import pandas as pd
-
-from qlib.backtest import Order
-from qlib.backtest.decision import OrderDir, TradeDecisionWO
-from qlib.contrib.strategy.signal_strategy import TopkDropoutStrategy
-
-try:
-    from qlib.data import D
-except ImportError:  # pragma: no cover - qlib always present in this stack
-    D = None
-
-__all__ = ["RegimeGateDropoutStrategy"]
-
-DEFAULT_REGIME_THRESHOLD = 0.5
-REGIME_FIELD = "$sp_hmm_p_regime1"
-
-
-class RegimeGateDropoutStrategy(TopkDropoutStrategy):
-    """TopkDropout with an HMM-regime entry gate on buy candidates.
-
-    Parameters
-    ----------
-    topk, n_drop, method_sell, method_buy, hold_thresh, only_tradable,
-    forbid_all_trade_at_limit : same as ``TopkDropoutStrategy``.
-    regime_threshold : minimum ``sp_hmm_p_regime1`` posterior required to open a
-        new position (default 0.5).
-    """
-
-    def __init__(self, *, topk, n_drop, regime_threshold: float = DEFAULT_REGIME_THRESHOLD, **kwargs):
-        super().__init__(topk=topk, n_drop=n_drop, **kwargs)
-        self.regime_threshold = regime_threshold
-
-    def _regime_for(self, codes, pred_start, pred_end) -> pd.Series:
-        """Return {code: sp_hmm_p_regime1} for the signal window (last day)."""
-        if D is None:
-            return pd.Series(dtype=float)
-        try:
-            df = D.features(list(codes), [REGIME_FIELD], start_time=pred_start, end_time=pred_end, freq="day")
-        except Exception:  # noqa: BLE001 - a regime read failure should gate open, not crash
-            return pd.Series(dtype=float)
-        if df is None or len(df) == 0:
-            return pd.Series(dtype=float)
-        # df index is MultiIndex (datetime, instrument); take the last day's values
-        df = df.reset_index()
-        ts_col = "datetime" if "datetime" in df.columns else df.columns[0]
-        sym_col = "instrument" if "instrument" in df.columns else df.columns[1]
-        last_ts = df[ts_col].max()
-        last = df[df[ts_col] == last_ts]
-        out = {}
-        for _, row in last.iterrows():
-            sym = str(row[sym_col]).split("/")[-1].upper()
-            val = row.iloc[-1]
-            out[sym] = float(val) if val == val else np.nan
-        return pd.Series(out)
-
-    def generate_trade_decision(self, execute_result=None):
-        import copy
-
-        trade_step = self.trade_calendar.get_trade_step()
-        trade_start_time, trade_end_time = self.trade_calendar.get_step_time(trade_step)
-        pred_start_time, pred_end_time = self.trade_calendar.get_step_time(trade_step, shift=1)
-        pred_score = self.signal.get_signal(start_time=pred_start_time, end_time=pred_end_time)
-        if isinstance(pred_score, pd.DataFrame):
-            pred_score = pred_score.iloc[:, 0]
-        if pred_score is None:
-            return TradeDecisionWO([], self)
-
-        if self.only_tradable:
-
-            def get_first_n(li, n, reverse=False):
-                cur_n = 0
-                res = []
-                for si in reversed(li) if reverse else li:
-                    if self.trade_exchange.is_stock_tradable(
-                        stock_id=si, start_time=trade_start_time, end_time=trade_end_time
-                    ):
-                        res.append(si)
-                        cur_n += 1
-                        if cur_n >= n:
-                            break
-                return res[::-1] if reverse else res
-
-            def get_last_n(li, n):
-                return get_first_n(li, n, reverse=True)
-
-            def filter_stock(li):
-                return [
-                    si
-                    for si in li
-                    if self.trade_exchange.is_stock_tradable(
-                        stock_id=si, start_time=trade_start_time, end_time=trade_end_time
-                    )
-                ]
-
-        else:
-
-            def get_first_n(li, n):
-                return list(li)[:n]
-
-            def get_last_n(li, n):
-                return list(li)[-n:]
-
-            def filter_stock(li):
-                return li
-
-        current_temp: "object" = copy.deepcopy(self.trade_position)
-        sell_order_list: List[Order] = []
-        buy_order_list: List[Order] = []
-        cash = current_temp.get_cash()
-        current_stock_list = current_temp.get_stock_list()
-        last = pred_score.reindex(current_stock_list).sort_values(ascending=False).index
-
-        if self.method_buy == "top":
-            today = get_first_n(
-                pred_score[~pred_score.index.isin(last)].sort_values(ascending=False).index,
-                self.n_drop + self.topk - len(last),
-            )
-        elif self.method_buy == "random":
-            topk_candi = get_first_n(pred_score.sort_values(ascending=False).index, self.topk)
-            candi = list(filter(lambda x: x not in last, topk_candi))
-            n = self.n_drop + self.topk - len(last)
-            try:
-                today = np.random.choice(candi, n, replace=False)
-            except ValueError:
-                today = candi
-        else:
-            raise NotImplementedError(f"This type of input is not supported")
-
-        comb = pred_score.reindex(last.union(pd.Index(today))).sort_values(ascending=False).index
-
-        if self.method_sell == "bottom":
-            sell = last[last.isin(get_last_n(comb, self.n_drop))]
-        elif self.method_sell == "random":
-            candi = filter_stock(last)
-            try:
-                sell = pd.Index(np.random.choice(candi, self.n_drop, replace=False) if len(last) else [])
-            except ValueError:
-                sell = candi
-        else:
-            raise NotImplementedError(f"This type of input is not supported")
-
-        buy = today[: len(sell) + self.topk - len(last)]
-
-        # ---- regime gate -----------------------------------------------------
-        if buy:
-            regime = self._regime_for(buy, pred_start_time, pred_end_time)
-            gated = [c for c in buy if regime.get(c, np.nan) >= self.regime_threshold]
-        else:
-            gated = []
-
-        for code in current_stock_list:
-            if not self.trade_exchange.is_stock_tradable(
-                stock_id=code,
-                start_time=trade_start_time,
-                end_time=trade_end_time,
-                direction=None if self.forbid_all_trade_at_limit else OrderDir.SELL,
-            ):
-                continue
-            if code in sell:
-                time_per_step = self.trade_calendar.get_freq()
-                if current_temp.get_stock_count(code, bar=time_per_step) < self.hold_thresh:
-                    continue
-                sell_amount = current_temp.get_stock_amount(code=code)
-                sell_order = Order(
-                    stock_id=code,
-                    amount=sell_amount,
-                    start_time=trade_start_time,
-                    end_time=trade_end_time,
-                    direction=Order.SELL,
-                )
-                if self.trade_exchange.check_order(sell_order):
-                    sell_order_list.append(sell_order)
-                    trade_val, trade_cost, trade_price = self.trade_exchange.deal_order(
-                        sell_order, position=current_temp
-                    )
-                    cash += trade_val - trade_cost
-
-        if len(gated) == 0:
-            return TradeDecisionWO(sell_order_list, self)
-
-        value = cash * self.risk_degree / len(gated)
-        for code in gated:
-            if not self.trade_exchange.is_stock_tradable(
-                stock_id=code,
-                start_time=trade_start_time,
-                end_time=trade_end_time,
-                direction=None if self.forbid_all_trade_at_limit else OrderDir.BUY,
-            ):
-                continue
-            buy_price = self.trade_exchange.get_deal_price(
-                stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=OrderDir.BUY
-            )
-            buy_amount = value / buy_price
-            factor = self.trade_exchange.get_factor(
-                stock_id=code, start_time=trade_start_time, end_time=trade_end_time
-            )
-            buy_amount = self.trade_exchange.round_amount_by_trade_unit(buy_amount, factor)
-            buy_order = Order(
-                stock_id=code,
-                amount=buy_amount,
-                start_time=trade_start_time,
-                end_time=trade_end_time,
-                direction=Order.BUY,
-            )
-            buy_order_list.append(buy_order)
-
-        return TradeDecisionWO(sell_order_list + buy_order_list, self)

code/tac-qlib/tac_qlib/contrib/strategy/top_bottom.py

@@ -1,169 +0,0 @@
-"""Market-neutral top/bottom long-short strategy for cross-sectional signals.
-
-Captures the cross-sectional long-short spread net of costs: buys the top-ranked
-``topk`` names and shorts the bottom-ranked ``topk`` names, equal-weight per
-side, sized to ``risk_degree`` of total value per side. Rebalances daily to the
-current rank (dropout-free: the book converges to the latest top/bottom sets).
-
-The long and short legs use equal notional per side (gross exposure ~2x
-``risk_degree`` of NAV, i.e. approximately market neutral before transaction
-costs). Benchmark neutrality (SPY beta ~ 0) is the secondary sanity metric.
-"""
-
-from __future__ import annotations
-
-from typing import List
-
-import copy
-
-import pandas as pd
-
-from qlib.backtest import Order
-from qlib.backtest.decision import OrderDir, TradeDecisionWO
-from qlib.contrib.strategy.signal_strategy import BaseSignalStrategy
-
-__all__ = ["TopBottomDropoutStrategy"]
-
-DEFAULT_SHORT_LEG = True
-DEFAULT_REBALANCE_DAILY = True
-
-
-class TopBottomDropoutStrategy(BaseSignalStrategy):
-    """Long top-k / short bottom-k equal-weight market-neutral book.
-
-    Parameters
-    ----------
-    topk : number of names on each side (long top-k and short bottom-k).
-    short_leg : whether to open the short side (if False, long-only topk).
-    rebalance_daily : if True rebalance to current rank every day; else keep
-        positions and only refresh on score changes (dropout-style).
-    risk_degree : fraction of total value deployed per side.
-    """
-
-    def __init__(
-        self,
-        *,
-        topk: int = 10,
-        short_leg: bool = DEFAULT_SHORT_LEG,
-        rebalance_daily: bool = DEFAULT_REBALANCE_DAILY,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self.topk = topk
-        self.short_leg = short_leg
-        self.rebalance_daily = rebalance_daily
-        self._prev_longs = set()
-        self._prev_shorts = set()
-
-    def generate_trade_decision(self, execute_result=None):
-        trade_step = self.trade_calendar.get_trade_step()
-        trade_start_time, trade_end_time = self.trade_calendar.get_step_time(trade_step)
-        pred_start_time, pred_end_time = self.trade_calendar.get_step_time(trade_step, shift=1)
-        pred_score = self.signal.get_signal(start_time=pred_start_time, end_time=pred_end_time)
-        if isinstance(pred_score, pd.DataFrame):
-            pred_score = pred_score.iloc[:, 0]
-        if pred_score is None or len(pred_score) == 0:
-            return TradeDecisionWO([], self)
-
-        # rank all names; topk longs and topk shorts
-        ranked = pred_score.sort_values(ascending=False)
-        longs = list(ranked.index[: self.topk])
-        shorts = list(ranked.index[-self.topk :]) if self.short_leg else []
-
-        current_temp: "object" = copy.deepcopy(self.trade_position)
-        current_codes = set(current_temp.get_stock_list())
-        holdings = {c: current_temp for c in current_codes if abs(current_temp.get_stock_amount(c)) > 1e-6}
-
-        sell_orders: List[Order] = []
-        buy_orders: List[Order] = []
-
-        def _tradable(code, direction):
-            try:
-                return self.trade_exchange.is_stock_tradable(
-                    stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=direction
-                )
-            except TypeError:
-                return self.trade_exchange.is_stock_tradable(
-                    stock_id=code, start_time=trade_start_time, end_time=trade_end_time
-                )
-
-        # determine target set (long/short)
-        target_longs = set(longs)
-        target_shorts = set(shorts)
-
-        # close positions not in the target book
-        for code in list(holdings):
-            if code in target_longs or code in target_shorts:
-                continue
-            amt = abs(current_temp.get_stock_amount(code))
-            o = Order(
-                stock_id=code,
-                amount=amt,
-                start_time=trade_start_time,
-                end_time=trade_end_time,
-                direction=Order.SELL if code in target_longs else Order.SELL,
-            )
-            if self.trade_exchange.check_order(o):
-                sell_orders.append(o)
-                self.trade_exchange.deal_order(o, position=current_temp)
-
-        # equal-weight notional per side
-        total_value = current_temp.get_cash()
-        for code, pos in holdings.items():
-            if code in target_longs or code in target_shorts:
-                mark = self.trade_exchange.get_deal_price(
-                    stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=Order.SELL
-                )
-                if mark is not None and mark == mark:
-                    total_value += abs(current_temp.get_stock_amount(code)) * mark
-
-        side_notional = total_value * self.risk_degree / max(1, self.topk)
-
-        for code in longs:
-            if code in holdings and abs(current_temp.get_stock_amount(code)) > 1e-6:
-                continue
-            px = self.trade_exchange.get_deal_price(
-                stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=Order.BUY
-            )
-            if px is None or px != px or px <= 0:
-                continue
-            amount = side_notional / px
-            factor = self.trade_exchange.get_factor(
-                stock_id=code, start_time=trade_start_time, end_time=trade_end_time
-            )
-            amount = self.trade_exchange.round_amount_by_trade_unit(amount, factor)
-            o = Order(
-                stock_id=code,
-                amount=amount,
-                start_time=trade_start_time,
-                end_time=trade_end_time,
-                direction=Order.BUY,
-            )
-            if self.trade_exchange.check_order(o):
-                buy_orders.append(o)
-
-        if self.short_leg:
-            for code in shorts:
-                if code in holdings and abs(current_temp.get_stock_amount(code)) > 1e-6:
-                    continue
-                px = self.trade_exchange.get_deal_price(
-                    stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=Order.SELL
-                )
-                if px is None or px != px or px <= 0:
-                    continue
-                amount = side_notional / px
-                factor = self.trade_exchange.get_factor(
-                    stock_id=code, start_time=trade_start_time, end_time=trade_end_time
-                )
-                amount = self.trade_exchange.round_amount_by_trade_unit(amount, factor)
-                o = Order(
-                    stock_id=code,
-                    amount=amount,
-                    start_time=trade_start_time,
-                    end_time=trade_end_time,
-                    direction=Order.SELL,
-                )
-                if self.trade_exchange.check_order(o):
-                    sell_orders.append(o)
-
-        return TradeDecisionWO(sell_orders + buy_orders, self)

code/tac-qlib/tac_qlib/contrib/strategy/weekly_rebalance.py

@@ -1,202 +0,0 @@
-"""Weekly-rebalance TopkDropout strategy.
-
-Turnover-reduction variant of ``qlib.contrib.strategy.signal_strategy.TopkDropoutStrategy``:
-the topk/n_drop selection and sizing are identical to the reference, but the
-target book is recomputed only on the first trading day of each ISO week; on the
-other days the strategy issues NO orders (holds the book untouched).
-
-The weekly cadence is derived from the qlib trade calendar: a rebalance happens
-when the current trade step's date belongs to a different ISO ``(year, week)``
-than the previous trade step. ``hold_band_pct`` (default 0) optionally skips
-tiny rebalances: when a name's existing position differs from the new target by
-less than this fraction, no order is generated for it.
-"""
-
-from __future__ import annotations
-
-from typing import List
-
-import numpy as np
-import pandas as pd
-
-from qlib.backtest import Order
-from qlib.backtest.decision import OrderDir, TradeDecisionWO
-from qlib.contrib.strategy.signal_strategy import TopkDropoutStrategy
-
-__all__ = ["WeeklyRebalanceDropoutStrategy"]
-
-DEFAULT_HOLD_BAND_PCT = 0.0
-
-
-class WeeklyRebalanceDropoutStrategy(TopkDropoutStrategy):
-    """TopkDropout rebalanced once per ISO week; holds otherwise.
-
-    Parameters
-    ----------
-    topk, n_drop, method_sell, method_buy, hold_thresh, only_tradable,
-    forbid_all_trade_at_limit : same as ``TopkDropoutStrategy``.
-    hold_band_pct : skip order for a name whose deviation from target weight is
-        below this fraction of the target (no-trade buffer band).
-    """
-
-    def __init__(self, *, topk, n_drop, hold_band_pct: float = DEFAULT_HOLD_BAND_PCT, **kwargs):
-        super().__init__(topk=topk, n_drop=n_drop, **kwargs)
-        self.hold_band_pct = hold_band_pct
-
-    @staticmethod
-    def _iso_week(ts) -> tuple:
-        return (ts.year, ts.week)
-
-    def generate_trade_decision(self, execute_result=None):
-        import copy
-
-        trade_step = self.trade_calendar.get_trade_step()
-        trade_start_time, trade_end_time = self.trade_calendar.get_step_time(trade_step)
-
-        cur_week = self._iso_week(trade_start_time)
-        prev_week = getattr(self, "_last_week", None)
-        self._last_week = cur_week
-
-        if prev_week is not None and prev_week == cur_week:
-            # not the first trading day of this ISO week -> hold
-            return TradeDecisionWO([], self)
-
-        pred_start_time, pred_end_time = self.trade_calendar.get_step_time(trade_step, shift=1)
-        pred_score = self.signal.get_signal(start_time=pred_start_time, end_time=pred_end_time)
-        if isinstance(pred_score, pd.DataFrame):
-            pred_score = pred_score.iloc[:, 0]
-        if pred_score is None:
-            return TradeDecisionWO([], self)
-
-        if self.only_tradable:
-
-            def get_first_n(li, n, reverse=False):
-                cur_n = 0
-                res = []
-                for si in reversed(li) if reverse else li:
-                    if self.trade_exchange.is_stock_tradable(
-                        stock_id=si, start_time=trade_start_time, end_time=trade_end_time
-                    ):
-                        res.append(si)
-                        cur_n += 1
-                        if cur_n >= n:
-                            break
-                return res[::-1] if reverse else res
-
-            def get_last_n(li, n):
-                return get_first_n(li, n, reverse=True)
-
-            def filter_stock(li):
-                return [
-                    si
-                    for si in li
-                    if self.trade_exchange.is_stock_tradable(
-                        stock_id=si, start_time=trade_start_time, end_time=trade_end_time
-                    )
-                ]
-
-        else:
-
-            def get_first_n(li, n):
-                return list(li)[:n]
-
-            def get_last_n(li, n):
-                return list(li)[-n:]
-
-            def filter_stock(li):
-                return li
-
-        current_temp: "object" = copy.deepcopy(self.trade_position)
-        sell_order_list: List[Order] = []
-        buy_order_list: List[Order] = []
-        cash = current_temp.get_cash()
-        current_stock_list = current_temp.get_stock_list()
-        last = pred_score.reindex(current_stock_list).sort_values(ascending=False).index
-
-        if self.method_buy == "top":
-            today = get_first_n(
-                pred_score[~pred_score.index.isin(last)].sort_values(ascending=False).index,
-                self.n_drop + self.topk - len(last),
-            )
-        elif self.method_buy == "random":
-            topk_candi = get_first_n(pred_score.sort_values(ascending=False).index, self.topk)
-            candi = list(filter(lambda x: x not in last, topk_candi))
-            n = self.n_drop + self.topk - len(last)
-            try:
-                today = np.random.choice(candi, n, replace=False)
-            except ValueError:
-                today = candi
-        else:
-            raise NotImplementedError(f"This type of input is not supported")
-
-        comb = pred_score.reindex(last.union(pd.Index(today))).sort_values(ascending=False).index
-
-        if self.method_sell == "bottom":
-            sell = last[last.isin(get_last_n(comb, self.n_drop))]
-        elif self.method_sell == "random":
-            candi = filter_stock(last)
-            try:
-                sell = pd.Index(np.random.choice(candi, self.n_drop, replace=False) if len(last) else [])
-            except ValueError:
-                sell = candi
-        else:
-            raise NotImplementedError(f"This type of input is not supported")
-
-        buy = today[: len(sell) + self.topk - len(last)]
-        for code in current_stock_list:
-            if not self.trade_exchange.is_stock_tradable(
-                stock_id=code,
-                start_time=trade_start_time,
-                end_time=trade_end_time,
-                direction=None if self.forbid_all_trade_at_limit else OrderDir.SELL,
-            ):
-                continue
-            if code in sell:
-                time_per_step = self.trade_calendar.get_freq()
-                if current_temp.get_stock_count(code, bar=time_per_step) < self.hold_thresh:
-                    continue
-                sell_amount = current_temp.get_stock_amount(code=code)
-                sell_order = Order(
-                    stock_id=code,
-                    amount=sell_amount,
-                    start_time=trade_start_time,
-                    end_time=trade_end_time,
-                    direction=Order.SELL,
-                )
-                if self.trade_exchange.check_order(sell_order):
-                    sell_order_list.append(sell_order)
-                    trade_val, trade_cost, trade_price = self.trade_exchange.deal_order(
-                        sell_order, position=current_temp
-                    )
-                    cash += trade_val - trade_cost
-
-        if len(buy) == 0:
-            return TradeDecisionWO(sell_order_list, self)
-
-        value = cash * self.risk_degree / len(buy)
-        for code in buy:
-            if not self.trade_exchange.is_stock_tradable(
-                stock_id=code,
-                start_time=trade_start_time,
-                end_time=trade_end_time,
-                direction=None if self.forbid_all_trade_at_limit else OrderDir.BUY,
-            ):
-                continue
-            buy_price = self.trade_exchange.get_deal_price(
-                stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=OrderDir.BUY
-            )
-            buy_amount = value / buy_price
-            factor = self.trade_exchange.get_factor(
-                stock_id=code, start_time=trade_start_time, end_time=trade_end_time
-            )
-            buy_amount = self.trade_exchange.round_amount_by_trade_unit(buy_amount, factor)
-            buy_order = Order(
-                stock_id=code,
-                amount=buy_amount,
-                start_time=trade_start_time,
-                end_time=trade_end_time,
-                direction=Order.BUY,
-            )
-            buy_order_list.append(buy_order)
-
-        return TradeDecisionWO(sell_order_list + buy_order_list, self)

code/tac-qlib/tac_qlib/data/__init__.py

@@ -1,25 +0,0 @@
-from .config import (
-    LakeConfig,
-    BAR_FIELD_MAP,
-    FREQ_TO_TIMEFRAME,
-    UNKNOWN_FIELD_NAMES,
-    timeframe_for_freq,
-    resolve_lake_root,
-)
-from .providers import (
-    LakeCalendarProvider,
-    LakeInstrumentProvider,
-    LakeFeatureProvider,
-)
-
-__all__ = [
-    "LakeConfig",
-    "BAR_FIELD_MAP",
-    "FREQ_TO_TIMEFRAME",
-    "UNKNOWN_FIELD_NAMES",
-    "timeframe_for_freq",
-    "resolve_lake_root",
-    "LakeCalendarProvider",
-    "LakeInstrumentProvider",
-    "LakeFeatureProvider",
-]

code/tac-qlib/tac_qlib/data/config.py

@@ -1,202 +0,0 @@
-"""TradeAC lake configuration helpers.
-
-The lake is a hive-partitioned parquet store (see ``tac-engine/skills/tradeac-lake``):
-
-    $TAC_LAKE_DIR/
-    ├── market=US/
-    │   └── timeframe=1d/
-    │       └── symbol=AAPL.parquet        # OHLCV bars: t, date, o, h, l, c, v, n, vw
-    ├── features/                          # indicators, wide format, family tier
-    │   └── market=US/
-    │       └── timeframe=1d/
-    │           ├── family=ta/symbol=AAPL.parquet  # t, sma_5, sma_20, rsi_14, ...
-    │           └── family=sp/symbol=AAPL.parquet  # t, sp_ou_*, sp_hmm_*, ...
-    ├── calendar.parquet                   # trading days per market
-    ├── coverage.parquet                   # per (market,timeframe,symbol) loaded windows
-    └── symbols.parquet                    # asset master
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-from typing import Dict, List, Optional
-
-import pandas as pd
-
-#: qlib freq string (Freq.__str__) -> lake timeframe partition name
-FREQ_TO_TIMEFRAME: Dict[str, str] = {
-    "day": "1d",
-    "1d": "1d",
-    "min": "1m",
-    "1min": "1m",
-    "5min": "5m",
-    "10min": "10m",
-    "15min": "15m",
-    "30min": "30m",
-    "hour": "1h",
-    "1hour": "1h",
-    "2hour": "2h",
-    "4hour": "4h",
-    "week": "1w",
-    "1week": "1w",
-    "month": "1M",
-    "1month": "1M",
-}
-
-#: bar-field map: qlib field name (without the leading ``$``) -> lake bar column
-BAR_FIELD_MAP: Dict[str, str] = {
-    "open": "o",
-    "high": "h",
-    "low": "l",
-    "close": "c",
-    "volume": "v",
-    "vwap": "vw",
-    "avg_amount": "vw",  # amount / volume
-}
-
-#: fields that qlib core/backtest queries but the lake does not store -> all-NaN
-UNKNOWN_FIELD_NAMES = ("factor", "change", "trade_unit", "suspend_flag")
-
-#: columns in the parquet files that are not features
-NON_FEATURE_COLUMNS = ("t", "date", "market", "timeframe", "symbol")
-
-
-def timeframe_for_freq(freq: str) -> str:
-    """Map a qlib frequency (e.g. ``day``, ``1min``) to a lake timeframe (e.g. ``1d``)."""
-    f = str(freq).lower()
-    if f not in FREQ_TO_TIMEFRAME:
-        raise ValueError(
-            f"unsupported qlib freq {freq!r}; supported freqs: {sorted(set(FREQ_TO_TIMEFRAME))}"
-        )
-    return FREQ_TO_TIMEFRAME[f]
-
-
-def resolve_lake_root(lake_root: Optional[str] = None) -> Path:
-    """Resolve the lake root: explicit arg > ``TAC_LAKE_DIR`` (no fallback).
-
-    ``TAC_LAKE_DIR`` is **mandatory** — there is deliberately no default
-    A missing/empty value raises so a
-    misconfigured environment never silently points at a wrong directory.
-    """
-    if lake_root is None:
-        lake_root = os.environ.get("TAC_LAKE_DIR")
-    if not lake_root:
-        raise RuntimeError(
-            "TAC_LAKE_DIR is not set. Point it at the TradeAC lake root, e.g. "
-            "export TAC_LAKE_DIR=/home/data/lake (docker) or set an absolute "
-            "path in your local .env."
-        )
-    return Path(str(lake_root)).expanduser().resolve()
-
-
-class LakeConfig:
-    """Path helpers + cached readers for a (lake_root, market) combination."""
-
-    def __init__(self, lake_root: Optional[str] = None, market: str = "US"):
-        self.lake_root: Path = resolve_lake_root(lake_root)
-        self.market: str = (market or "US").upper()
-
-    # ---- paths --------------------------------------------------------------
-    def bar_dir(self, timeframe: str) -> Path:
-        return self.lake_root / f"market={self.market}" / f"timeframe={timeframe}"
-
-    def bar_path(self, timeframe: str, symbol: str) -> Path:
-        return self.bar_dir(timeframe) / f"symbol={str(symbol).upper()}.parquet"
-
-    def features_dir(self, timeframe: str) -> Path:
-        return self.lake_root / "features" / f"market={self.market}" / f"timeframe={timeframe}"
-
-    def features_path(self, timeframe: str, symbol: str) -> Path:
-        # Legacy flat path (no family tier). Prefer `load_features` which
-        # resolves the family=ta|sp partition layout.
-        return self.features_dir(timeframe) / f"symbol={str(symbol).upper()}.parquet"
-
-    def load_features(self, timeframe: str, symbol: str) -> pd.DataFrame:
-        """All feature columns for a symbol, merging the `family=ta` and
-        `family=sp` partitions by timestamp. Returns an empty frame when no
-        feature files exist (legacy flat layout falls back transparently)."""
-        sym = str(symbol).upper()
-        frames = []
-        for family in ("ta", "sp"):
-            p = self.features_dir(timeframe) / f"family={family}" / f"symbol={sym}.parquet"
-            if p.exists():
-                frames.append(pd.read_parquet(p))
-        if not frames:
-            flat = self.features_dir(timeframe) / f"symbol={sym}.parquet"
-            if flat.exists():
-                return pd.read_parquet(flat)
-            return pd.DataFrame()
-        if len(frames) == 1:
-            return frames[0]
-        merged = frames[0]
-        for extra in frames[1:]:
-            merged = merged.merge(extra, on="t", how="outer", suffixes=("", "_dup"))
-            for c in [c for c in merged.columns if c.endswith("_dup")]:
-                merged = merged.drop(columns=c)
-        return merged
-
-    def calendar_path(self) -> Path:
-        return self.lake_root / "calendar.parquet"
-
-    def symbols_path(self) -> Path:
-        return self.lake_root / "symbols.parquet"
-
-    def coverage_path(self) -> Path:
-        return self.lake_root / "coverage.parquet"
-
-    # ---- metadata readers ----------------------------------------------------
-    def load_symbols(self) -> List[str]:
-        """All symbols known to the lake (from ``symbols.parquet``)."""
-        p = self.symbols_path()
-        if not p.exists():
-            return []
-        df = pd.read_parquet(p)
-        if "symbol" not in df.columns:
-            return []
-        return sorted(df["symbol"].astype(str).str.upper().tolist())
-
-    def symbol_spans(self, symbol: str, timeframe: str) -> List[tuple]:
-        """Listing span(s) ``[(start_iso, end_iso)]`` for a symbol from coverage.parquet."""
-        p = self.coverage_path()
-        if p.exists():
-            try:
-                df = pd.read_parquet(p)
-            except Exception:  # pragma: no cover - defensive
-                df = pd.DataFrame()
-            if len(df):
-                df = df[
-                    (df.get("market") == self.market)
-                    & (df.get("timeframe") == timeframe)
-                    & (df.get("symbol") == str(symbol).upper())
-                ]
-                if len(df):
-                    row = df.iloc[0]
-                    first = pd.Timestamp(row["first_t"]).date()
-                    last = pd.Timestamp(row["last_t"]).date()
-                    return [(first.isoformat(), last.isoformat())]
-        # fallback: derive from the bar file itself
-        p = self.bar_path(timeframe, symbol)
-        if p.exists():
-            import pyarrow.parquet as pq
-
-            tbl = pq.read_table(p, columns=["t"])
-            first = pd.Timestamp(tbl.column("t")[0].as_py()).date()
-            last = pd.Timestamp(tbl.column("t")[-1].as_py()).date()
-            return [(first.isoformat(), last.isoformat())]
-        return [("1970-01-01", "2099-12-31")]
-
-    def load_calendar_dates(self) -> List[pd.Timestamp]:
-        """Trading days (midnight timestamps) for the market, from ``calendar.parquet``."""
-        p = self.calendar_path()
-        if p.exists():
-            df = pd.read_parquet(p)
-            if "date" in df.columns:
-                if "market" in df.columns:
-                    df = df[df["market"] == self.market]
-                dates = pd.to_datetime(df["date"]).dt.normalize().sort_values().unique()
-                return [pd.Timestamp(x) for x in dates]
-        return []
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"LakeConfig(lake_root={self.lake_root}, market={self.market})"

code/tac-qlib/tac_qlib/data/providers.py

@@ -1,230 +0,0 @@
-"""qlib data providers backed by the TradeAC parquet lake.
-
-These providers plug into the standard qlib mechanism: ``qlib.init(calendar_provider=...,
-instrument_provider=..., feature_provider=...)`` instantiates them and binds them to the
-``Cal`` / ``Inst`` / ``FeatureD`` wrappers (see ``qlib.data.data.register_all_wrappers``).
-The rest of qlib (``LocalDatasetProvider`` expression engine, backtest ``Exchange``) keeps
-working unchanged because the interface contract is identical to the file-based providers:
-
-- ``feature()`` returns a ``pd.Series`` indexed by the **calendar position** range
-  ``[start_index, end_index]`` (matching ``FileFeatureStorage.__getitem__`` semantics).
-- ``list_instruments()`` returns ``{symbol: [(start, end), ...]}``.
-- ``load_calendar()`` returns a list of ``pd.Timestamp`` trading days.
-"""
-
-from __future__ import annotations
-
-import bisect
-from typing import Dict, List, Optional, Union
-
-import numpy as np
-import pandas as pd
-
-from qlib.data.data import CalendarProvider, FeatureProvider, InstrumentProvider
-from qlib.log import get_module_logger
-
-from .config import (
-    BAR_FIELD_MAP,
-    LakeConfig,
-    UNKNOWN_FIELD_NAMES,
-    timeframe_for_freq,
-)
-
-logger = get_module_logger("tac_qlib.data.providers")
-
-
-def _day_freq(freq: str) -> bool:
-    return str(freq).lower() in ("day", "1d")
-
-
-def _calendar_keys(cal: List[pd.Timestamp], freq: str) -> pd.Index:
-    """Convert calendar timestamps into the same key space as the lake parquet."""
-    if _day_freq(freq):
-        return pd.Index([pd.Timestamp(x).date() for x in cal])
-    return pd.Index([pd.Timestamp(x) for x in cal])
-
-
-class LakeCalendarProvider(CalendarProvider):
-    """Trading calendar read from ``<lake>/calendar.parquet`` (fallback: derived from bars)."""
-
-    def __init__(self, lake_root: Optional[str] = None, market: str = "US"):
-        super().__init__()
-        self.cfg = LakeConfig(lake_root, market)
-
-    def load_calendar(self, freq, future):
-        timeframe = timeframe_for_freq(freq)
-        if not _day_freq(freq):
-            raise NotImplementedError(
-                f"freq={freq!r} (timeframe={timeframe}) is not supported yet: the lake calendar "
-                f"only covers daily sessions; add a minute-level calendar to `calendar.parquet`"
-            )
-
-        dates = self.cfg.load_calendar_dates()
-        if not dates:
-            # Fallback: derive the trading-day set from the persisted bar files.
-            bar_dir = self.cfg.bar_dir(timeframe)
-            if bar_dir.exists():
-                import pyarrow.parquet as pq
-
-                cal: Dict[pd.Timestamp, None] = {}
-                for p in sorted(bar_dir.glob("symbol=*.parquet")):
-                    tbl = pq.read_table(p, columns=["t"])
-                    for v in tbl.column("t"):
-                        cal[pd.Timestamp(v.as_py()).normalize()] = None
-                dates = sorted(cal.keys())
-            if not dates:
-                return []
-
-        if future:
-            # append the next calendar day so that "today" is a valid trade date
-            last = dates[-1]
-            dates = dates + [pd.Timestamp(last) + pd.Timedelta(days=1)]
-        return dates
-
-
-class LakeInstrumentProvider(InstrumentProvider):
-    """Instruments from ``<lake>/symbols.parquet`` with listing spans from ``coverage.parquet``."""
-
-    def __init__(
-        self,
-        lake_root: Optional[str] = None,
-        market: str = "US",
-        markets: Optional[Dict[str, list]] = None,
-    ):
-        super().__init__()
-        self.cfg = LakeConfig(lake_root, market)
-        #: optional named pools, e.g. ``{"sp500": ["AAPL", "MSFT"], "etf": ["SPY"]}``.
-        #: ``all`` / any unregistered name resolves to every symbol in the lake.
-        self.markets: Dict[str, list] = markets or {}
-
-    def _resolve_symbols(self, market: Union[str, list]) -> List[str]:
-        if isinstance(market, (list, tuple, pd.Index, np.ndarray)):
-            return [str(s).upper() for s in market]
-        if isinstance(market, str) and "," in market:
-            return [s.strip().upper() for s in market.split(",") if s.strip()]
-        if market in self.markets:
-            return [str(s).upper() for s in self.markets[market]]
-        return self.cfg.load_symbols()
-
-    def list_instruments(self, instruments, start_time=None, end_time=None, freq="day", as_list=False):
-        market = instruments["market"]
-        timeframe = timeframe_for_freq(freq)
-
-        symbols = self._resolve_symbols(market)
-        if not symbols:
-            if as_list:
-                return []
-            return {}
-
-        # clip listing spans to the queried window (mirror of LocalInstrumentProvider)
-        from qlib.data.data import Cal  # pylint: disable=C0415
-
-        cal = Cal.calendar(freq=freq)
-        start_time = pd.Timestamp(start_time or cal[0])
-        end_time = pd.Timestamp(end_time or cal[-1])
-
-        out: Dict[str, list] = {}
-        for symbol in symbols:
-            spans = []
-            for begin, end in self.cfg.symbol_spans(symbol, timeframe):
-                lo = max(start_time, pd.Timestamp(begin))
-                hi = min(end_time, pd.Timestamp(end))
-                if lo <= hi:
-                    spans.append((lo, hi))
-            if spans:
-                out[symbol] = spans
-
-        filter_pipe = instruments.get("filter_pipe") or []
-        for filter_config in filter_pipe:
-            from qlib.data import filter as F  # pylint: disable=C0415
-
-            filter_t = getattr(F, filter_config["filter_type"]).from_config(filter_config)
-            out = filter_t(out, start_time, end_time, freq)
-
-        if as_list:
-            return list(out)
-        return out
-
-
-class LakeFeatureProvider(FeatureProvider):
-    """Feature data from the lake parquet (OHLCV bars + pre-computed ta-lib features).
-
-    Field routing:
-        - ``$open/$high/$low/$close/$volume/$vwap``      -> bar parquet columns
-        - ``$amount`` (= v*vw), ``$avg_amount`` (= vw)  -> derived from bar parquet
-        - ``$factor/$change/...``                        -> all-NaN (not stored)
-        - anything else                                  -> a ta-lib column in the features parquet
-    """
-
-    def __init__(self, lake_root: Optional[str] = None, market: str = "US"):
-        super().__init__()
-        self.cfg = LakeConfig(lake_root, market)
-        self._bar_cache: Dict[tuple, pd.DataFrame] = {}
-        self._feature_cache: Dict[tuple, pd.DataFrame] = {}
-
-    # ------------------------------------------------------------------ caches
-    def _load_bar_df(self, instrument: str, timeframe: str) -> pd.DataFrame:
-        key = (instrument, timeframe)
-        if key not in self._bar_cache:
-            p = self.cfg.bar_path(timeframe, instrument)
-            self._bar_cache[key] = pd.read_parquet(p) if p.exists() else pd.DataFrame()
-        return self._bar_cache[key]
-
-    def _load_feature_df(self, instrument: str, timeframe: str) -> pd.DataFrame:
-        key = (instrument, timeframe)
-        if key not in self._feature_cache:
-            self._feature_cache[key] = self.cfg.load_features(timeframe, instrument)
-        return self._feature_cache[key]
-
-    @staticmethod
-    def _keys(df: pd.DataFrame, freq: str) -> pd.Index:
-        ts = pd.to_datetime(df["t"])
-        return ts.dt.date if _day_freq(freq) else ts
-
-    # ------------------------------------------------------------------ fields
-    def _extract(self, instrument: str, field: str, timeframe: str, freq: str) -> Optional[pd.Series]:
-        """Return the field as a Series keyed by date/timestamp (None if not present in the lake)."""
-        bar = self._load_bar_df(instrument, timeframe)
-
-        if field in BAR_FIELD_MAP:
-            col = BAR_FIELD_MAP[field]
-            if col in bar.columns:
-                return bar[col].astype(float).set_axis(self._keys(bar, freq))
-            return None
-        if field == "amount":
-            if "v" in bar.columns and "vw" in bar.columns:
-                return (bar["v"] * bar["vw"]).astype(float).set_axis(self._keys(bar, freq))
-            return None
-        if field in UNKNOWN_FIELD_NAMES:
-            return None
-
-        feat = self._load_feature_df(instrument, timeframe)
-        if field in feat.columns:
-            return feat[field].astype(float).set_axis(self._keys(feat, freq))
-        return None
-
-    # ------------------------------------------------------------------ api
-    def _get_calendar(self, freq: str) -> List[pd.Timestamp]:
-        from qlib.data.data import Cal  # pylint: disable=C0415
-
-        cal = Cal.calendar(freq=freq)
-        return list(cal)
-
-    def feature(self, instrument, field, start_index, end_index, freq):
-        field = str(field)[1:]
-        timeframe = timeframe_for_freq(freq)
-
-        cal = self._get_calendar(freq)
-        n = len(cal)
-        lo = max(0, int(start_index))
-        hi = min(n - 1, int(end_index))
-        if lo > hi:
-            return pd.Series(dtype=np.float32)
-
-        keys = _calendar_keys(cal[lo : hi + 1], freq)
-        ser = self._extract(str(instrument).upper(), field, timeframe, freq)
-        if ser is None:
-            vals = np.full(len(keys), np.nan, dtype=np.float64)
-        else:
-            vals = ser.reindex(keys).to_numpy(dtype=np.float64)
-        return pd.Series(vals, index=pd.RangeIndex(lo, hi + 1))

queue/README.md

@@ -1,69 +0,0 @@
-# TradeAC Experiment Queue — Series 2 (Q12+)
-
-**Purpose.** The next pre-registered batch of experiments, continuing Series 1
-(Q01–Q11, exp 33–43, all executed and folded into `book/CLAIMS.md` /
-`book/EVIDENCE.md`). Each entry targets a still-unproven `HYPOTHESIS` from the
-book or an open question flagged in `CLAIMS.md`/`book/README.md`, and follows the
-Series-1 discipline: one variable changed vs the exp-26 reference, acceptance
-fixed BEFORE the run, sequential execution, trace-first, verify-then-close.
-
-**Reference / control (MUST reproduce first).** exp 26 (`21afc6af…`, mlflow exp
-25) is the campaign baseline; exp 39 (Q07, weekly rebalance) is the best
-construction. Reference config is byte-reproduced in `workflows/exp26/` on the
-`exp/26-…` branch and in this dir's `workflows/*.yaml`.
-
-| Config element | exp-26 reference value |
-|---|---|
-| Universe | 50-ETF panel (`UNIVERSE` below) |
-| Features | compact stochastic 25-field set (no ou/hmm/moments/garch) |
-| Label | `Ref($close,-6)/Ref($close,-1)-1` (5d) |
-| Model | `RankICEnsembleLGBModel`, seeds `42,7,2026,99,123`, lr 0.02, leaves 31, 3000 rounds, ES 200 |
-| Segments | train 2016-01-04..2025-09-01 / valid 2025-09-03..2026-01-03 / test 2026-01-04..2026-08-10 |
-| Strategy | TopkDropout, topk 10, n_drop 1, risk_degree 0.95 |
-| Costs | open 0.0005 / close 0.0015 / min $5, deal $close, SPY benchmark, $1M |
-
-**Reference metrics to beat (EVIDENCE#015):** net_ann +2.13%, net_IR 0.21, gross
-+7.02%, maxDD −7.69%, RankIC 0.0663, RankICIR 0.2545, L/S Sharpe 4.54. Weekly
-(Q07, EVIDENCE#028): net +12.51%, IR 1.24, maxDD −4.13%, ~1.1pp cost drag.
-
-## The queue (ordered by value × feasibility)
-
-| ID | Title / hypothesis | Change vs reference (ONE var) | Acceptance | Config | Ready? |
-|----|--------------------|-------------------------------|------------|--------|--------|
-| Q12 | **22d label + weekly recompute** — the untested combo: Q05's label edge (IC 0.097, RankIC 0.117) with Q07's cost relief | label → 22d AND strategy → weekly (two coupled, explicitly pre-registered) | net_IR > 0.5, net_ann > +5%, cost drag ≤ 2pp | `workflows/q12_label22d_weekly.yaml` | ✅ |
-| Q13 | **Weekly rebalance reproduction on a 2nd window** — Q07 was a single OOS window; reproduce on test 2025-01-02..2025-12-31 before promoting to a live round | segments only (shifted) | net_IR > 0.21, net_ann > +2.13% on the new window | `workflows/q13_weekly_second_window.yaml` | ✅ |
-| Q14 | **Out-of-universe validation** — compact stochastic set generalizes off the 50-ETF panel to a single-stock universe | universe → 30 liquid single names | RankIC > 0.03, ICIR > 0.15, net IR > 0 on stocks | `workflows/q14_out_of_universe.yaml` | ⚠️ needs stock-lake backfill (see design) |
-| Q15 | **5-seed vs single-model clean A/B** — seed-count claim (exp 12 idea, re-validated exp 22–24, never a clean A/B) | seeds → 1 (`2026`) | single-model RankIC/IR < 5-seed ref; net_IR ≥ 0.21 acceptable if ≥ single | `workflows/q15_single_seed.yaml` | ✅ |
-| Q16 | **HMM family added as features** — settles "dropping model-specific (ou,hmm) improves signal" (exp 25 tested OU; hmm-as-feature untested) | features += `sp_hmm_p_regime1,sp_hmm_state` | no improvement: RankIC ≤ 0.0663, net_IR ≤ 0.21 | `workflows/q16_hmm_features.yaml` | ✅ |
-| Q17 | **Realized-moments family added** — settles "moment/volatility families regress" (exp 11 idea, never clean A/B) | features += `sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_5,sp_dsv_22` | no improvement: RankIC ≤ 0.0663, net_IR ≤ 0.21 | `workflows/q17_moments_features.yaml` | ✅ |
-| Q18 | **OptimalStopControl clean re-test** — exp 13/14 claim (TopkDropout > stop-control) never re-tested post-reset | strategy → `OptimalStopControl` (exp-13 params) | TopkDropout net_IR ≥ stop-control net_IR; document cost drag | `workflows/q18_optstop.yaml` | ✅ (module verified in venv) |
-| Q19 | **Martingale / variance-ratio study close-out** — exp 19 never closed; VR<1 at 5–20d on clean lake | ad-hoc script (no qrun) | VR stats + drift decomposition on 50-ETF panel | `designs/q19_martingale_vr.md` | ✅ script |
-| Q20 | **Effective independent names (≈4)** — eigenvalue analysis on clean-lake covariance | ad-hoc script | eigenvalue spectrum + effective-rank count | `designs/q20_effective_names.md` | ✅ script |
-
-### Deferred (methodology / infra, P3)
-- Purged / walk-forward CV (was queue's old Q12) — methodology, not an alpha lever.
-- PSI-based drift-aware retraining cadence — needs a drift-gate module + a retrain decision rule.
-- No-trade buffer band / notional-vs-qty sizing — siblings of Q12/Q13; queue only if weekly reproduces.
-- Macro/drift overlays (SPY>200d regime gate, momentum tilt) — needs new data pipeline.
-
-## Execution protocol (per queued run)
-
-1. **Validate the lake first** (`validate_lake_dataset` + `rd_status`) — clean-lake lesson: silent NaN-drops and hollow coverage invalidate a run. Q14 additionally requires backfilling the single-stock universe (bars + sp/ta features, full range, explicit `start`/`end`).
-2. **Trace before running** (`rd_trace_start` with the hypothesis as `rational`, fresh `experiment_name`, `evolved_from=auto`).
-3. **Run** `rd_run_workflow config_path=<abs path to the queue YAML> experiment_name=<fresh name>` — `wait=false`, poll `rd_exp_get_run` until `FINISHED`.
-4. **Verify against acceptance** via `rd_exp_result` (headline + backtest risk).
-5. **Finish the trace** (`rd_trace_finish` with `metrics` + `evaluation`), snapshot any changed contrib modules.
-6. **Report to the book** — PROVE/REFUTE → update `book/CLAIMS.md` + `book/EVIDENCE.md`.
-
-Sequential execution only (concurrent runs hang — chat-ideas.md ops lesson). Any
-custom strategy/module changed here must be copied into the venv site-packages
-snapshot before `rd_run_workflow` can import it (see `/app/AGENTS.md`). As of
-2026-08-20 `WeeklyRebalanceDropoutStrategy` and `OptimalStopControl` are verified
-in sync with the venv snapshot; the lake already persists the `sp_hmm_*` and
-`sp_moments` families on the 50-ETF panel.
-
-## Provenance
-
-Mined 2026-08-20 from `book/CLAIMS.md`, `book/EVIDENCE.md`, `book/README.md`,
-`book/references/chat-ideas.md`, and Series-1 `queue/` (Q01–Q11, executed exp
-33–43). Reference numbers are post-clean-lake (exp 21+).

queue/designs/q19_martingale_vr.md

@@ -1,26 +0,0 @@
-# QUEUE-19 — Martingale / variance-ratio study close-out (no qrun)
-
-**Status:** QUEUED · **Priority:** P2 · **Effort:** ad-hoc script under `book/data/`
-
-## Hypothesis (settle)
-Assets are submartingales long-horizon / mean-reverting short-horizon
-(`VR < 1` at 5–20d). CLAIMS.md marks this HYPOTHESIS (chat-derived martingale
-study; exp 19 was opened but never closed). It is a market-structure claim, not a
-trading claim — settle it with a clean-lake script, then close exp 19 or open a
-scripted EVIDENCE entry.
-
-## Method (persist everything under `book/data/evidence/q19-vr/`)
-1. Load the 50-ETF panel 1d bars from the lake for 2015-01-01..2026-08-19.
-2. Compute the Lo–MacKinlay variance ratio at horizons 5 / 10 / 20d per symbol,
-   with heteroskedasticity-robust z-stats.
-3. Report: per-horizon VR distribution, fraction of symbols with VR < 1 and the
-   z-significance, pooled drift vs daily variance (submartingale check).
-4. Cross-check the pooled `sp_trend_slope_5` regression beta claim (β ≈ −0.53,
-   t ≈ −24) on the clean lake.
-5. Write `VR_stats.csv` + a one-page summary into the evidence dir.
-
-## Acceptance
-- VR < 1 at 5–20d for a material fraction of the panel with |z| > 2 → supports
-  the mean-reversion HYPOTHESIS; else mark REFUTED or REFERENCED.
-- The result updates CLAIMS.md's "Assets are submartingales…" row and closes the
-  exp-19 open thread.

queue/designs/q20_effective_names.md

@@ -1,22 +0,0 @@
-# QUEUE-20 — Effective independent names in the 50-ETF book (no qrun)
-
-**Status:** QUEUED · **Priority:** P2 · **Effort:** ad-hoc script under `book/data/`
-
-## Hypothesis (settle)
-The 50-ETF book has only ~4 effective independent names (CLAIMS.md HYPOTHESIS,
-chat-derived eigenvalue analysis, pre-reset). This is a concentration/diversification
-claim with direct sizing relevance; verify it on the clean lake.
-
-## Method (persist everything under `book/data/evidence/q20-effective-names/`)
-1. Load the 50-ETF panel 1d returns from the lake for the test window 2026-01-04..2026-08-10.
-2. Standardize returns; compute the correlation matrix and its eigendecomposition.
-3. Count eigenvalues above the Marchenko–Pastur bound (N=50, T≈150) and report the
-   cumulative-variance share of the top k components.
-4. Effective-rank measures: participation ratio `(Σλ)² / Σλ²` and cumulative 80%
-   variance count.
-5. Write `eigenanalysis.csv` + a one-page summary.
-
-## Acceptance
-- If effective rank ≈ 4 (top-4 explain ~80%+ variance), the concentration claim is
-  PROVEN and feeds chapter 08 sizing guidance (why topk 10→20 adds no breadth).
-- If effective rank is much larger, mark the claim REFUTED.

queue/workflows/q12_label22d_weekly.yaml

@@ -1,105 +0,0 @@
-# QUEUE-12 — Long-horizon label (22d) + weekly recompute construction.
-# Untested combination from book/CLAIMS.md open questions: Q05 (exp 37) proved the
-# 22d label has the strongest signal (IC 0.097, RankIC 0.117) but daily turnover
-# killed the book (net -4.60%); Q07 (exp 39) proved weekly recompute is the cost
-# lever (net +12.51%). Hypothesis: pairing them monetizes the label edge.
-# Change vs exp-26 reference: label 5d -> 22d AND strategy -> WeeklyRebalanceDropoutStrategy.
-# Acceptance: net_IR > 0.5, net_ann > +5%, cost drag <= 2pp.
-# Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q12_label22d_weekly.yaml \
-#        experiment_name=tac-rd-q12-label22d-weekly
-{%- set LAKE = TAC_LAKE_DIR %}
-{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
-{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
-
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q12-label22d-weekly" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "{{ UNIVERSE }}"
-                    start_time: 2015-01-03
-                    end_time: 2026-08-10
-                    fit_start_time: 2016-01-04
-                    fit_end_time: 2025-09-01
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-23)/Ref($close,-1)-1"
-                    feature_fields: "{{ FEATURES }}"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: [2016-01-04, 2025-09-01]
-                valid: [2025-09-03, 2026-01-03]
-                test: [2026-01-04, 2026-08-10]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: WeeklyRebalanceDropoutStrategy
-                      module_path: tac_qlib.contrib.strategy.weekly_rebalance
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: 2026-01-04
-                      end_time: 2026-08-10
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "{{ UNIVERSE }}"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

queue/workflows/q13_weekly_second_window.yaml

@@ -1,106 +0,0 @@
-# QUEUE-13 — Weekly rebalance reproduction on a second OOS window.
-# Q07 (exp 39) proved weekly recompute on test 2026-01-04..2026-08-10 (net +12.51%,
-# IR 1.24) but that is a single OOS window. Before promoting the weekly construction
-# to a live round, reproduce it on a disjoint window: test 2025-01-02..2025-12-31
-# with train/valid shifted to end 2024.
-# Change vs exp-26 reference: segments shifted only (train ends 2024-08, test = 2025);
-# strategy is the SAME weekly recompute as exp 39. Label stays 5d.
-# Acceptance: net_IR > 0.21 AND net_ann > +2.13% on the 2025 window.
-# Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q13_weekly_second_window.yaml \
-#        experiment_name=tac-rd-q13-weekly-second-window
-{%- set LAKE = TAC_LAKE_DIR %}
-{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
-{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
-
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q13-weekly-second-window" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "{{ UNIVERSE }}"
-                    start_time: 2015-01-03
-                    end_time: 2025-12-31
-                    fit_start_time: 2016-01-04
-                    fit_end_time: 2024-08-30
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "{{ FEATURES }}"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: [2016-01-04, 2024-08-30]
-                valid: [2024-09-03, 2024-12-31]
-                test: [2025-01-02, 2025-12-31]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: WeeklyRebalanceDropoutStrategy
-                      module_path: tac_qlib.contrib.strategy.weekly_rebalance
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: 2025-01-02
-                      end_time: 2025-12-31
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "{{ UNIVERSE }}"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

queue/workflows/q14_out_of_universe.yaml

@@ -1,107 +0,0 @@
-# QUEUE-14 — Out-of-universe validation: compact stochastic set on single-stock names.
-# The 50-ETF panel results (compact feature set, RankIC 0.0663) are panel-specific;
-# book/CLAIMS.md marks "generalizes to other universes" HYPOTHESIS - TODO(evidence-needed).
-# Change vs exp-26 reference: universe -> 30 liquid US single-stock names.
-# PREREQUISITE: backfill lake bars + sp/ta features for these symbols (full range,
-# explicit start/end) — the stock panel currently has only ~180d of data (2025-12-01+).
-# Backfill: get_lake_bars symbols=... start=2000-01-03 then
-#   get_lake_sp symbol=<s> start=2000-01-03 end=<today> fit_end=<train-end> persist=true
-# Acceptance: RankIC > 0.03, ICIR > 0.15, net IR > 0 on the stock universe.
-# Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q14_out_of_universe.yaml \
-#        experiment_name=tac-rd-q14-out-of-universe
-{%- set LAKE = TAC_LAKE_DIR %}
-{%- set UNIVERSE = "AAPL,MSFT,NVDA,AMZN,GOOGL,META,TSLA,AVGO,AMD,JPM,UNH,PG,JNJ,MA,V,WMT,DIS,HD,KO,PEP,BAC,XOM,MCD,ABBV,COST,CRM,NFLX,ORCL,IBM,T" %}
-{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
-
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q14-out-of-universe" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "{{ UNIVERSE }}"
-                    start_time: 2015-01-03
-                    end_time: 2026-08-10
-                    fit_start_time: 2016-01-04
-                    fit_end_time: 2025-09-01
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "{{ FEATURES }}"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: [2016-01-04, 2025-09-01]
-                valid: [2025-09-03, 2026-01-03]
-                test: [2026-01-04, 2026-08-10]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: 2026-01-04
-                      end_time: 2026-08-10
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "{{ UNIVERSE }}"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

queue/workflows/q15_single_seed.yaml

@@ -1,104 +0,0 @@
-# QUEUE-15 — 5-seed vs single-model clean A/B on the compact stochastic set.
-# CLAIMS.md HYPOTHESIS: "5-seed RankIC ensemble raises performance vs single model
-# on ablated set" — pre-clean-lake exp 12 idea, re-validated directionally by exp
-# 22–24, never a clean A/B post-reset. Seed count is load-bearing (exp 28: 2<5).
-# Change vs exp-26 reference: seeds "42,7,2026,99,123" -> single seed "2026".
-# Acceptance: single-model RankIC < 0.0663, net_IR < 0.21 (ensemble beats single).
-# Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q15_single_seed.yaml \
-#        experiment_name=tac-rd-q15-single-seed
-{%- set LAKE = TAC_LAKE_DIR %}
-{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
-{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
-
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q15-single-seed" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "2026"
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "{{ UNIVERSE }}"
-                    start_time: 2015-01-03
-                    end_time: 2026-08-10
-                    fit_start_time: 2016-01-04
-                    fit_end_time: 2025-09-01
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "{{ FEATURES }}"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: [2016-01-04, 2025-09-01]
-                valid: [2025-09-03, 2026-01-03]
-                test: [2026-01-04, 2026-08-10]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: 2026-01-04
-                      end_time: 2026-08-10
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "{{ UNIVERSE }}"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

queue/workflows/q16_hmm_features.yaml

@@ -1,105 +0,0 @@
-# QUEUE-16 — HMM family added as model features to the compact set.
-# CLAIMS.md HYPOTHESIS: "Dropping model-specific feature families (ou, hmm)
-# improves the rank signal" — exp 25 cleanly tested OU (adding it hurts: IC 0.0511->0.0343);
-# hmm-as-features has NOT been clean A/B'd post-reset (exp 42 tested hmm as an entry
-# GATE overlay, refuted). This run adds the hmm family columns to the compact set.
-# Change vs exp-26 reference: features += sp_hmm_p_regime1, sp_hmm_state.
-# Acceptance (prune-hypothesis): no improvement — RankIC <= 0.0663, net_IR <= 0.21.
-# Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q16_hmm_features.yaml \
-#        experiment_name=tac-rd-q16-hmm-features
-{%- set LAKE = TAC_LAKE_DIR %}
-{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
-{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_hmm_p_regime1,sp_hmm_state" %}
-
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q16-hmm-features" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "{{ UNIVERSE }}"
-                    start_time: 2015-01-03
-                    end_time: 2026-08-10
-                    fit_start_time: 2016-01-04
-                    fit_end_time: 2025-09-01
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "{{ FEATURES }}"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: [2016-01-04, 2025-09-01]
-                valid: [2025-09-03, 2026-01-03]
-                test: [2026-01-04, 2026-08-10]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: 2026-01-04
-                      end_time: 2026-08-10
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "{{ UNIVERSE }}"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

queue/workflows/q17_moments_features.yaml

@@ -1,105 +0,0 @@
-# QUEUE-17 — Realized-moments family added to the compact set.
-# CLAIMS.md HYPOTHESIS: "Adding moment/volatility families regresses the signal"
-# (idea: pre-clean-lake exp 11). M1 momentum bundle (exp 29) and M3 GARCH (exp 31)
-# were refuted post-reset; the realized-moments family (sp_rskew/sp_rkurt/sp_dsv)
-# has NOT been clean A/B'd. This run adds the moments columns to the compact set.
-# Change vs exp-26 reference: features += sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_5,sp_dsv_22.
-# Acceptance (prune-hypothesis): no improvement — RankIC <= 0.0663, net_IR <= 0.21.
-# Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q17_moments_features.yaml \
-#        experiment_name=tac-rd-q17-moments-features
-{%- set LAKE = TAC_LAKE_DIR %}
-{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
-{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_5,sp_dsv_22" %}
-
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q17-moments-features" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "{{ UNIVERSE }}"
-                    start_time: 2015-01-03
-                    end_time: 2026-08-10
-                    fit_start_time: 2016-01-04
-                    fit_end_time: 2025-09-01
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "{{ FEATURES }}"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: [2016-01-04, 2025-09-01]
-                valid: [2025-09-03, 2026-01-03]
-                test: [2026-01-04, 2026-08-10]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: 2026-01-04
-                      end_time: 2026-08-10
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "{{ UNIVERSE }}"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

queue/workflows/q18_optstop.yaml

@@ -1,106 +0,0 @@
-# QUEUE-18 — OptimalStopControl clean re-test vs TopkDropout (exp 13/14 claim).
-# CLAIMS.md HYPOTHESIS: "TopkDropout beats stochastic-control OptimalStopControl on
-# the ensemble signal" — exp 13/14 were pre-clean-lake; never re-tested post-reset.
-# Same compact signal as the exp-26 reference; ONLY the strategy changes to
-# OptimalStopControl with exp-13 params (entry 0.85 / exit 0.7 / hold 10 / sl -0.08).
-# PREREQUISITE: tac_qlib/contrib/strategy/optimal_stop.py must be synced to the venv
-# site-packages snapshot before running (see /app/AGENTS.md).
-# Acceptance: TopkDropout net_IR >= stop-control net_IR; document cost drag of both.
-# Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q18_optstop.yaml \
-#        experiment_name=tac-rd-q18-optstop
-{%- set LAKE = TAC_LAKE_DIR %}
-{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
-{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
-
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q18-optstop" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "{{ UNIVERSE }}"
-                    start_time: 2015-01-03
-                    end_time: 2026-08-10
-                    fit_start_time: 2016-01-04
-                    fit_end_time: 2025-09-01
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "{{ FEATURES }}"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: [2016-01-04, 2025-09-01]
-                valid: [2025-09-03, 2026-01-03]
-                test: [2026-01-04, 2026-08-10]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: OptimalStopControl
-                      module_path: tac_qlib.contrib.strategy.optimal_stop
-                      kwargs: { signal: "<PRED>", topk: 10, entry_pct: 0.85, exit_pct: 0.7, max_hold_days: 10, min_hold_days: 2, sl: -0.08 }
-                  backtest:
-                      start_time: 2026-01-04
-                      end_time: 2026-08-10
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "{{ UNIVERSE }}"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/7-baseline-lightgbm-on-60etf-lake-ta-featu/workflow.yaml

@@ -0,0 +1,108 @@
+# Exp 7 (baseline) — LightGBM on the 60-ETF lake, typical algo-trading hyperparams.
+# Universe: all 60 lake ETFs. Features: OHLCV + 28 ta-lib (auto-discovered).
+# train 2022-01-01..2025-06-30 / valid 2025-07-01..2025-12-31 / test 2026-01-01..2026-08-12
+{%- set LAKE = TAC_LAKE_DIR %}
+
+qlib_init:
+    provider_uri: "{{ LAKE }}"
+    region: us
+    expression_cache: null
+    dataset_cache: null
+
+    calendar_provider:
+        class: tac_qlib.data.providers.LakeCalendarProvider
+        kwargs:
+            lake_root: "{{ LAKE }}"
+            market: US
+    instrument_provider:
+        class: tac_qlib.data.providers.LakeInstrumentProvider
+        kwargs:
+            lake_root: "{{ LAKE }}"
+            market: US
+            markets: {}
+    feature_provider:
+        class: tac_qlib.data.providers.LakeFeatureProvider
+        kwargs:
+            lake_root: "{{ LAKE }}"
+            market: US
+
+    exp_manager:
+        class: MLflowExpManager
+        module_path: qlib.workflow.expm
+        kwargs:
+            uri: "sqlite:///mlruns.db"
+            default_exp_name: "tac-lake-lgb-baseline"
+
+task:
+    model:
+        class: LGBModel
+        module_path: qlib.contrib.model.gbdt
+        kwargs:
+            loss: mse
+            learning_rate: 0.05
+            num_leaves: 64
+            n_estimators: 200
+            colsample_bytree: 0.8
+            subsample: 0.8
+            subsample_freq: 1
+            reg_alpha: 0.01
+            reg_lambda: 0.01
+
+    dataset:
+        class: DatasetH
+        module_path: qlib.data.dataset
+        kwargs:
+            handler:
+                class: TACHandler
+                module_path: tac_qlib.contrib.data.handler
+                kwargs:
+                    instruments: all
+                    start_time: 2021-10-01
+                    end_time: 2026-08-12
+                    fit_start_time: 2022-01-01
+                    fit_end_time: 2025-06-30
+                    freq: day
+                    lake_root: "{{ LAKE }}"
+                    market: US
+            segments:
+                train: [2022-01-01, 2025-06-30]
+                valid: [2025-07-01, 2025-12-31]
+                test: [2026-01-01, 2026-08-12]
+
+    record:
+        - class: SignalRecord
+          module_path: qlib.workflow.record_temp
+          kwargs: {}
+
+        - class: SigAnaRecord
+          module_path: qlib.workflow.record_temp
+          kwargs:
+              ana_long_short: true
+              ann_scaler: 252
+
+        - class: PortAnaRecord
+          module_path: qlib.workflow.record_temp
+          kwargs:
+              config:
+                  strategy:
+                      class: TopkDropoutStrategy
+                      module_path: qlib.contrib.strategy
+                      kwargs:
+                          signal: "<PRED>"
+                          topk: 2
+                          n_drop: 1
+                          only_tradable: true
+                          risk_degree: 0.95
+                  backtest:
+                      start_time: 2026-01-01
+                      end_time: 2026-08-12
+                      account: 1000000
+                      benchmark: SPY
+                      exchange_kwargs:
+                          codes: all
+                          deal_price: $close
+                          freq: day
+                          open_cost: 0.0005
+                          close_cost: 0.0015
+                          min_cost: 5.0
+              risk_analysis_freq: 1d