start experiment 59 (exp/59-signal-quality-gate-walk-forward-test-wi)

book/scripts/precompute_signal_quality_gate.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""Precompute the signal-quality gate series and save to pickle.
+
+Usage:
+    python precompute_signal_quality_gate.py <pred_path> <output_path> [topk] [lookback] [threshold]
+
+Example:
+    python precompute_signal_quality_gate.py \
+        /home/data/lake/mlruns/49/34165f27e4a34378ad54843a079a78c0/artifacts/pred.pkl \
+        /app/experiments/book/data/signal_quality_gate/sq_gate_5d_0.50.pkl \
+        10 5 0.5
+"""
+import sys
+import pickle
+from pathlib import Path
+
+# Add tac-qlib to path
+sys.path.insert(0, "/app/tac-qlib")
+
+from tac_qlib.contrib.strategy.signal_quality_gate import compute_signal_quality_gate
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print(__doc__)
+        sys.exit(1)
+
+    pred_path = sys.argv[1]
+    output_path = sys.argv[2]
+    topk = int(sys.argv[3]) if len(sys.argv) > 3 else 10
+    lookback = int(sys.argv[4]) if len(sys.argv) > 4 else 5
+    threshold = float(sys.argv[5]) if len(sys.argv) > 5 else 0.5
+
+    lake_root = "/home/data/lake"
+
+    print(f"Computing signal-quality gate: topk={topk}, lookback={lookback}, threshold={threshold}")
+    gate = compute_signal_quality_gate(
+        pred_path,
+        lake_root=lake_root,
+        topk=topk,
+        lookback=lookback,
+        threshold=threshold,
+    )
+
+    print(f"Gate: {gate.sum()}/{len(gate)} days open ({gate.mean():.1%})")
+
+    with open(output_path, "wb") as f:
+        pickle.dump(gate, f)
+    print(f"Saved to {output_path}")

book/workflows/signal_quality_gate.yaml

@@ -1,16 +1,16 @@
 # -----------------------------------------------------------------------------
-# ABLATION A (baseline): LightGBM with RankIC early-stopping on the 50-ETF SP-5d
+# Signal-quality gate: TopkDropout gated by rolling hit-rate of topk picks.
-# panel, using ALL 24 sp_* feature columns (ou,hmm,jump,har,trend,hurst,
-# signature). Copy of the canonical workflow_lgb_sp5d_rankic.yaml with a
-# distinct experiment name so the ablation runs are isolated.
 #
-# Run:
+# 1. Compute the gate: python precompute_signal_quality_gate.py <pred.pkl> <gate.pkl>
-#   rd_run_workflow config_path=tac-qlib/workflows/ablate_baseline_all_sp_fields.yaml \
+# 2. Run this workflow: rd_run_workflow config_path=<this yaml> experiment_name=<exp>
-#       experiment_name=tac-rd-rank-ablate
+#
+# The strategy loads the precomputed gate from signal_quality_gate_path.
+# When hit rate >= threshold, trade; otherwise, go to cash.
 # -----------------------------------------------------------------------------
 {%- 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 SP_FIELDS = "sp_ret,sp_ou_zscore,sp_ou_half_life,sp_ou_revert,sp_hmm_p_regime1,sp_hmm_state,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" %}
+{%- set GATE_PATH = "/app/experiments/book/data/signal_quality_gate/sq_gate_5d_0.50.pkl" %}
 
 qlib_init:
     provider_uri: "{{ LAKE }}"
@@ -40,27 +40,22 @@ qlib_init:
         module_path: qlib.workflow.expm
         kwargs:
             uri: "sqlite:///{{ LAKE }}/mlruns.db"
-            default_exp_name: "tac-rd-rank-ablate"
+            default_exp_name: "tac-rd-sq-gate"
 
 task:
     model:
-        class: RankICLGBModel
+        class: LGBModel
-        module_path: tac_qlib.contrib.model.rank_gbdt
+        module_path: qlib.contrib.model.gbdt
         kwargs:
             loss: mse
-            learning_rate: 0.02
+            learning_rate: 0.05
-            num_leaves: 31
+            num_leaves: 15
-            n_estimators: 3000
+            n_estimators: 200
-            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_alpha: 0.01
-            reg_lambda: 1.0
+            reg_lambda: 0.01
-            seed: 42
 
     dataset:
         class: DatasetH
@@ -110,12 +105,13 @@ task:
           kwargs:
               config:
                   strategy:
-                      class: TopkDropoutStrategy
+                      class: SignalQualityGateStrategy
-                      module_path: qlib.contrib.strategy
+                      module_path: tac_qlib.contrib.strategy.signal_quality_gate
                       kwargs:
                           signal: "<PRED>"
+                          signal_quality_gate_path: "{{ GATE_PATH }}"
                           topk: 10
-                          n_drop: 2
+                          n_drop: 1
                           only_tradable: true
                           risk_degree: 0.95
                   backtest:

book/workflows/sq_gate/sq_gate_2021.yaml

@@ -1,74 +1,44 @@
-# -----------------------------------------------------------------------------
+# Signal-quality gate backtest for 2021
-# ISOLATION: multi-seed RankIC ensemble, ablate-B generic-only feature set.
-#
-# Isolates the ensemble effect on the SP-5d rank signal. Same panel, segments,
-# history (full backfilled 2016+) and feature set as the exp-9 ablate-B winner
-# (generic-only sp_* families: jump,har,trend,hurst,signature), but replaces the
-# single RankICLGBModel with a 5-seed RankICEnsembleLGBModel (42,7,2026,99,123)
-# that averages per-day predictions.
-#
-# Differs from exp-15 (tac-rd-rank-ensemble, mlflow exp 15) ONLY by dropping the
-# TA subset (rsi_14,roc_10,macd_hist,willr_14,atr_14) and the inter-asset xr_*
-# features, so any change vs exp-15 is attributable to the feature set alone,
-# and any change vs exp-9 is attributable to the ensemble + full history alone.
-#
-# Run:
-#   rd_run_workflow config_path=experiments/workflows/exp12_isolation_ensemble.yaml \
-#       experiment_name=tac-rd-rank-ensemble-isolated
-# -----------------------------------------------------------------------------
 {%- 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 SP_FIELDS = "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" %}
+{%- set SP_FIELDS = "sp_ret,sp_ou_zscore,sp_ou_half_life,sp_ou_revert,sp_hmm_p_regime1,sp_hmm_state,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" %}
+{# Gate computed on-the-fly from signal + lake close prices #}
 
 qlib_init:
     provider_uri: "{{ LAKE }}"
     region: us
     expression_cache: null
     dataset_cache: null
-
     calendar_provider:
         class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs:
+        kwargs: { lake_root: "{{ LAKE }}", market: US }
-            lake_root: "{{ LAKE }}"
-            market: US
     instrument_provider:
         class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs:
+        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-            lake_root: "{{ LAKE }}"
-            market: US
-            markets: {}
     feature_provider:
         class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs:
+        kwargs: { lake_root: "{{ LAKE }}", market: US }
-            lake_root: "{{ LAKE }}"
-            market: US
-
     exp_manager:
         class: MLflowExpManager
         module_path: qlib.workflow.expm
         kwargs:
-            uri: "sqlite:///mlruns.db"
+            uri: "sqlite:///{{ LAKE }}/mlruns.db"
-            default_exp_name: "tac-rd-rank-ensemble-isolated"
+            default_exp_name: "tac-rd-sq-gate-2021"
 
 task:
     model:
-        class: RankICEnsembleLGBModel
+        class: LGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
+        module_path: qlib.contrib.model.gbdt
         kwargs:
             loss: mse
-            learning_rate: 0.02
+            learning_rate: 0.05
-            num_leaves: 31
+            num_leaves: 15
-            n_estimators: 3000
+            n_estimators: 200
-            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_alpha: 0.01
-            reg_lambda: 1.0
+            reg_lambda: 0.01
-            seeds: "42,7,2026,99,123"
 
     dataset:
         class: DatasetH
@@ -80,9 +50,9 @@ task:
                 kwargs:
                     instruments: "{{ UNIVERSE }}"
                     start_time: 2015-01-03
-                    end_time: 2026-08-14
+                    end_time: 2021-12-31
-                    fit_start_time: 2016-01-04
+                    fit_start_time: 2015-01-03
-                    fit_end_time: 2025-09-01
+                    fit_end_time: 2021-01-03
                     freq: day
                     lake_root: "{{ LAKE }}"
                     market: US
@@ -100,9 +70,9 @@ task:
                         - class: Fillna
                           kwargs: {}
             segments:
-                train: [2016-01-04, 2025-09-01]
+                train: [2015-01-03, 2020-09-01]
-                valid: [2025-09-03, 2026-01-03]
+                valid: [2020-09-03, 2021-01-03]
-                test: [2026-01-04, 2026-08-10]
+                test: [2021-01-04, 2021-12-31]
 
     record:
         - class: SignalRecord
@@ -110,25 +80,29 @@ task:
           kwargs: {}
         - class: SigAnaRecord
           module_path: qlib.workflow.record_temp
-          kwargs:
+          kwargs: { ana_long_short: true, ann_scaler: 252 }
-              ana_long_short: true
-              ann_scaler: 252
         - class: PortAnaRecord
           module_path: qlib.workflow.record_temp
           kwargs:
               config:
                   strategy:
-                      class: TopkDropoutStrategy
+                      class: SignalQualityGateStrategy
-                      module_path: qlib.contrib.strategy
+                      module_path: tac_qlib.contrib.strategy.signal_quality_gate
                       kwargs:
                           signal: "<PRED>"
+                          lake_root: "{{ LAKE }}"
+                          gate_topk: 10
+                          gate_lookback: 5
+                          gate_threshold: 0.5
+                          gate_start: "2015-01-03"
+                          gate_end: "2021-12-31"
                           topk: 10
-                          n_drop: 2
+                          n_drop: 1
                           only_tradable: true
                           risk_degree: 0.95
                   backtest:
-                      start_time: 2026-01-04
+                      start_time: 2021-01-04
-                      end_time: 2026-08-10
+                      end_time: 2021-12-31
                       account: 1000000
                       benchmark: SPY
                       exchange_kwargs:

book/workflows/sq_gate/sq_gate_2023.yaml

@@ -0,0 +1,115 @@
+# Signal-quality gate backtest for 2023
+{%- 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 SP_FIELDS = "sp_ret,sp_ou_zscore,sp_ou_half_life,sp_ou_revert,sp_hmm_p_regime1,sp_hmm_state,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" %}
+{# Gate computed on-the-fly from signal + lake close prices #}
+
+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:///{{ LAKE }}/mlruns.db"
+            default_exp_name: "tac-rd-sq-gate-2023"
+
+task:
+    model:
+        class: LGBModel
+        module_path: qlib.contrib.model.gbdt
+        kwargs:
+            loss: mse
+            learning_rate: 0.05
+            num_leaves: 15
+            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: "{{ UNIVERSE }}"
+                    start_time: 2015-01-03
+                    end_time: 2023-12-29
+                    fit_start_time: 2015-01-03
+                    fit_end_time: 2023-01-03
+                    freq: day
+                    lake_root: "{{ LAKE }}"
+                    market: US
+                    label: "Ref($close,-6)/Ref($close,-1)-1"
+                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,{{ SP_FIELDS }}"
+                    infer_processors:
+                        - class: DropAllNaN
+                          kwargs: {}
+                        - class: ProcessInf
+                          kwargs: {}
+                        - class: CSRankNorm
+                          kwargs: {}
+                        - class: ZScoreNorm
+                          kwargs: {}
+                        - class: Fillna
+                          kwargs: {}
+            segments:
+                train: [2015-01-03, 2022-09-01]
+                valid: [2022-09-03, 2023-01-03]
+                test: [2023-01-03, 2023-12-29]
+
+    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: SignalQualityGateStrategy
+                      module_path: tac_qlib.contrib.strategy.signal_quality_gate
+                      kwargs:
+                          signal: "<PRED>"
+                          lake_root: "{{ LAKE }}"
+                          gate_topk: 10
+                          gate_lookback: 5
+                          gate_threshold: 0.5
+                          gate_start: "2015-01-03"
+                          gate_end: "2023-12-29"
+                          topk: 10
+                          n_drop: 1
+                          only_tradable: true
+                          risk_degree: 0.95
+                  backtest:
+                      start_time: 2023-01-03
+                      end_time: 2023-12-29
+                      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

book/workflows/sq_gate/sq_gate_2024.yaml

@@ -0,0 +1,115 @@
+# Signal-quality gate backtest for 2024
+{%- 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 SP_FIELDS = "sp_ret,sp_ou_zscore,sp_ou_half_life,sp_ou_revert,sp_hmm_p_regime1,sp_hmm_state,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" %}
+{# Gate computed on-the-fly from signal + lake close prices #}
+
+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:///{{ LAKE }}/mlruns.db"
+            default_exp_name: "tac-rd-sq-gate-2024"
+
+task:
+    model:
+        class: LGBModel
+        module_path: qlib.contrib.model.gbdt
+        kwargs:
+            loss: mse
+            learning_rate: 0.05
+            num_leaves: 15
+            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: "{{ UNIVERSE }}"
+                    start_time: 2015-01-03
+                    end_time: 2024-12-31
+                    fit_start_time: 2015-01-03
+                    fit_end_time: 2024-01-03
+                    freq: day
+                    lake_root: "{{ LAKE }}"
+                    market: US
+                    label: "Ref($close,-6)/Ref($close,-1)-1"
+                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,{{ SP_FIELDS }}"
+                    infer_processors:
+                        - class: DropAllNaN
+                          kwargs: {}
+                        - class: ProcessInf
+                          kwargs: {}
+                        - class: CSRankNorm
+                          kwargs: {}
+                        - class: ZScoreNorm
+                          kwargs: {}
+                        - class: Fillna
+                          kwargs: {}
+            segments:
+                train: [2015-01-03, 2023-09-01]
+                valid: [2023-09-03, 2024-01-03]
+                test: [2024-01-02, 2024-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: SignalQualityGateStrategy
+                      module_path: tac_qlib.contrib.strategy.signal_quality_gate
+                      kwargs:
+                          signal: "<PRED>"
+                          lake_root: "{{ LAKE }}"
+                          gate_topk: 10
+                          gate_lookback: 5
+                          gate_threshold: 0.5
+                          gate_start: "2015-01-03"
+                          gate_end: "2024-12-31"
+                          topk: 10
+                          n_drop: 1
+                          only_tradable: true
+                          risk_degree: 0.95
+                  backtest:
+                      start_time: 2024-01-02
+                      end_time: 2024-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

book/workflows/sq_gate/sq_gate_2025.yaml

@@ -1,74 +1,44 @@
-# -----------------------------------------------------------------------------
+# Signal-quality gate backtest for 2025
-# EXP 18 - Risk-limit control: reference model + TopkDropout baseline (A).
-#
-# Signal/model identical to the reference (tac-rd-rank-ensemble-isolated,
-# run 0cea66d9...): RankICEnsembleLGBModel (parallel, 5 seeds) on the 50-ETF
-# SP-5d panel, test 2026-01-04..2026-08-10. This workflow reproduces the
-# unconstrained TopkDropout baseline net-of-cost so the risk-limited variant
-# (same pred, liquidity/size/concentration caps) can be compared 1:1.
-#
-# The risk_limits spec itself is applied via rd_backtest / rd_strategy_targets
-# (tool-level param, not a YAML key); this run records the unconstrained
-# baseline that the limit A/B is measured against.
-#
-# Run:
-#   rd_run_workflow config_path=experiments/workflows/exp18-risk-limit/a_baseline.yaml \
-#       experiment_name=tac-rd-risk-limit
-# -----------------------------------------------------------------------------
 {%- 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 SP_FIELDS = "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" %}
+{%- set SP_FIELDS = "sp_ret,sp_ou_zscore,sp_ou_half_life,sp_ou_revert,sp_hmm_p_regime1,sp_hmm_state,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" %}
+{# Gate computed on-the-fly from signal + lake close prices #}
 
 qlib_init:
     provider_uri: "{{ LAKE }}"
     region: us
     expression_cache: null
     dataset_cache: null
-
     calendar_provider:
         class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs:
+        kwargs: { lake_root: "{{ LAKE }}", market: US }
-            lake_root: "{{ LAKE }}"
-            market: US
     instrument_provider:
         class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs:
+        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-            lake_root: "{{ LAKE }}"
-            market: US
-            markets: {}
     feature_provider:
         class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs:
+        kwargs: { lake_root: "{{ LAKE }}", market: US }
-            lake_root: "{{ LAKE }}"
-            market: US
-
     exp_manager:
         class: MLflowExpManager
         module_path: qlib.workflow.expm
         kwargs:
             uri: "sqlite:///{{ LAKE }}/mlruns.db"
-            default_exp_name: "tac-rd-risk-limit"
+            default_exp_name: "tac-rd-sq-gate-2025"
 
 task:
     model:
-        class: RankICEnsembleLGBModel
+        class: LGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
+        module_path: qlib.contrib.model.gbdt
         kwargs:
             loss: mse
-            learning_rate: 0.02
+            learning_rate: 0.05
-            num_leaves: 31
+            num_leaves: 15
-            n_estimators: 3000
+            n_estimators: 200
-            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_alpha: 0.01
-            reg_lambda: 1.0
+            reg_lambda: 0.01
-            seeds: "42,7,2026,99,123"
-            parallel: 5
 
     dataset:
         class: DatasetH
@@ -80,9 +50,9 @@ task:
                 kwargs:
                     instruments: "{{ UNIVERSE }}"
                     start_time: 2015-01-03
-                    end_time: 2026-08-14
+                    end_time: 2025-12-31
-                    fit_start_time: 2016-01-04
+                    fit_start_time: 2015-01-03
-                    fit_end_time: 2025-09-01
+                    fit_end_time: 2026-01-03
                     freq: day
                     lake_root: "{{ LAKE }}"
                     market: US
@@ -100,9 +70,9 @@ task:
                         - class: Fillna
                           kwargs: {}
             segments:
-                train: [2016-01-04, 2025-09-01]
+                train: [2015-01-03, 2025-09-01]
                 valid: [2025-09-03, 2026-01-03]
-                test: [2026-01-04, 2026-08-10]
+                test: [2025-01-02, 2025-12-31]
 
     record:
         - class: SignalRecord
@@ -110,25 +80,29 @@ task:
           kwargs: {}
         - class: SigAnaRecord
           module_path: qlib.workflow.record_temp
-          kwargs:
+          kwargs: { ana_long_short: true, ann_scaler: 252 }
-              ana_long_short: true
-              ann_scaler: 252
         - class: PortAnaRecord
           module_path: qlib.workflow.record_temp
           kwargs:
               config:
                   strategy:
-                      class: TopkDropoutStrategy
+                      class: SignalQualityGateStrategy
-                      module_path: qlib.contrib.strategy
+                      module_path: tac_qlib.contrib.strategy.signal_quality_gate
                       kwargs:
                           signal: "<PRED>"
+                          lake_root: "{{ LAKE }}"
+                          gate_topk: 10
+                          gate_lookback: 5
+                          gate_threshold: 0.5
+                          gate_start: "2015-01-03"
+                          gate_end: "2025-12-31"
                           topk: 10
-                          n_drop: 2
+                          n_drop: 1
                           only_tradable: true
                           risk_degree: 0.95
                   backtest:
-                      start_time: 2026-01-04
+                      start_time: 2025-01-02
-                      end_time: 2026-08-10
+                      end_time: 2025-12-31
                       account: 1000000
                       benchmark: SPY
                       exchange_kwargs:

book/workflows/sq_gate/sq_gate_2026.yaml

@@ -1,67 +1,44 @@
-# -----------------------------------------------------------------------------
+# Signal-quality gate backtest for 2026
-# ABLATION B (generic-only): same panel/model as the baseline, but feature
-# fields restricted to the model-free / generic stochastic-process families
-# (jump,har,trend,hurst,signature). Drops the model-specific ou (OU/AR-1
-# half-life) and hmm (2-state regime) families to test whether the generic
-# families alone dominate the rank dimension.
-#
-# Run:
-#   rd_run_workflow config_path=tac-qlib/workflows/ablate_generic_only_sp_fields.yaml \
-#       experiment_name=tac-rd-rank-ablate
-# -----------------------------------------------------------------------------
 {%- 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 SP_FIELDS = "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" %}
+{%- set SP_FIELDS = "sp_ret,sp_ou_zscore,sp_ou_half_life,sp_ou_revert,sp_hmm_p_regime1,sp_hmm_state,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" %}
+{# Gate computed on-the-fly from signal + lake close prices #}
 
 qlib_init:
     provider_uri: "{{ LAKE }}"
     region: us
     expression_cache: null
     dataset_cache: null
-
     calendar_provider:
         class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs:
+        kwargs: { lake_root: "{{ LAKE }}", market: US }
-            lake_root: "{{ LAKE }}"
-            market: US
     instrument_provider:
         class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs:
+        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-            lake_root: "{{ LAKE }}"
-            market: US
-            markets: {}
     feature_provider:
         class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs:
+        kwargs: { lake_root: "{{ LAKE }}", market: US }
-            lake_root: "{{ LAKE }}"
-            market: US
-
     exp_manager:
         class: MLflowExpManager
         module_path: qlib.workflow.expm
         kwargs:
             uri: "sqlite:///{{ LAKE }}/mlruns.db"
-            default_exp_name: "tac-rd-rank-ablate"
+            default_exp_name: "tac-rd-sq-gate-2026"
 
 task:
     model:
-        class: RankICLGBModel
+        class: LGBModel
-        module_path: tac_qlib.contrib.model.rank_gbdt
+        module_path: qlib.contrib.model.gbdt
         kwargs:
             loss: mse
-            learning_rate: 0.02
+            learning_rate: 0.05
-            num_leaves: 31
+            num_leaves: 15
-            n_estimators: 3000
+            n_estimators: 200
-            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_alpha: 0.01
-            reg_lambda: 1.0
+            reg_lambda: 0.01
-            seed: 42
 
     dataset:
         class: DatasetH
@@ -75,7 +52,7 @@ task:
                     start_time: 2015-01-03
                     end_time: 2026-08-10
                     fit_start_time: 2015-01-03
-                    fit_end_time: 2025-09-01
+                    fit_end_time: 2026-01-03
                     freq: day
                     lake_root: "{{ LAKE }}"
                     market: US
@@ -103,20 +80,24 @@ task:
           kwargs: {}
         - class: SigAnaRecord
           module_path: qlib.workflow.record_temp
-          kwargs:
+          kwargs: { ana_long_short: true, ann_scaler: 252 }
-              ana_long_short: true
-              ann_scaler: 252
         - class: PortAnaRecord
           module_path: qlib.workflow.record_temp
           kwargs:
               config:
                   strategy:
-                      class: TopkDropoutStrategy
+                      class: SignalQualityGateStrategy
-                      module_path: qlib.contrib.strategy
+                      module_path: tac_qlib.contrib.strategy.signal_quality_gate
                       kwargs:
                           signal: "<PRED>"
+                          lake_root: "{{ LAKE }}"
+                          gate_topk: 10
+                          gate_lookback: 5
+                          gate_threshold: 0.5
+                          gate_start: "2015-01-03"
+                          gate_end: "2026-08-19"
                           topk: 10
-                          n_drop: 2
+                          n_drop: 1
                           only_tradable: true
                           risk_degree: 0.95
                   backtest:

code/MANIFEST.txt

@@ -1,31 +1,35 @@
 # TradeAC custom-qlib-code snapshot (auto-generated)
-# parent repo HEAD : 507846cee16eeee11daf33c4176e8aec79b985b2
+# parent repo HEAD : e952feed0a66a20439f4f24ad5524233429cd0c3
 #   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
+  861592c63edd6a0853a9cb174b5970435b135fc8  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
+  5c547a2ef92e075e550fe6d01508a2f1d3f536bc  tac-qlib/tac_qlib/contrib/data/__pycache__/__init__.cpython-312.pyc
-  fdd5923a70a399e8680913593ff111641947898e  tac-qlib/tac_qlib/contrib/data/__pycache__/handler.cpython-312.pyc
+  4f656130d167e79dcaaeb7783a121f0b36852374  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
+  b1489f2fc0dee85f0a4f90b2e6ad545ed9c8967b  tac-qlib/tac_qlib/contrib/model/__pycache__/__init__.cpython-312.pyc
-  6fb61946ea9a83dfb560de3717f5fbf482c4c00e  tac-qlib/tac_qlib/contrib/model/__pycache__/rank_ensemble.cpython-312.pyc
+  121ef237da1df1b8e21a561c3ad0db200b901339  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
+  74d0da348cbcc3700c96b6f4fe4391488e61efc5  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
+  2c2f167b693f4366a769998e3c9d4804f29e31e0  tac-qlib/tac_qlib/contrib/strategy/__init__.py
-  6ad10c2ebe37c16417e67c7aeb731ad1fcb6da2f  tac-qlib/tac_qlib/contrib/strategy/__pycache__/__init__.cpython-312.pyc
+  f9cd9ab729e3248542ccc490af7adc2e51c71914  tac-qlib/tac_qlib/contrib/strategy/__pycache__/__init__.cpython-312.pyc
-  8d684b3216b040071d9ee4fa920a0e0c7486d278  tac-qlib/tac_qlib/contrib/strategy/__pycache__/optimal_stop.cpython-312.pyc
+  cd3133cfbd2556b25c106e39ae97fb128df0e326  tac-qlib/tac_qlib/contrib/strategy/__pycache__/ic_gate.cpython-312.pyc
-  896ef74ae47bcd1ed388e1e5d9c8d70c28097fe9  tac-qlib/tac_qlib/contrib/strategy/kelly_dropout.py
+  6dd1c568a2961842793674390d5abffd1a0e71b8  tac-qlib/tac_qlib/contrib/strategy/__pycache__/optimal_stop.cpython-312.pyc
+  03b5e4d80da00800f1b108bee0735d3d18d856d1  tac-qlib/tac_qlib/contrib/strategy/__pycache__/regime_gate.cpython-312.pyc
+  a6a1c21ab71b62080830df45c4784b73c1531036  tac-qlib/tac_qlib/contrib/strategy/__pycache__/signal_quality_gate.cpython-312.pyc
+  755e3b139496a5e22b0328db45c8199c33029fbc  tac-qlib/tac_qlib/contrib/strategy/__pycache__/weekly_rebalance.cpython-312.pyc
+  519a1f4c05dbe0ac018ab8b779eb33d53b4dd545  tac-qlib/tac_qlib/contrib/strategy/ic_gate.py
   79aaad9e39fcc740a773f4f63c512ce1086cfde0  tac-qlib/tac_qlib/contrib/strategy/optimal_stop.py
-  5b9acfb4340111b204249add7760bd53c6ae03f1  tac-qlib/tac_qlib/contrib/strategy/regime_gate.py
+  7bcee5f0b09cfa721440f1354f16f2dd9a112b12  tac-qlib/tac_qlib/contrib/strategy/regime_gate.py
-  aa1ee880d52ceb5821d65973962099c2254f710a  tac-qlib/tac_qlib/contrib/strategy/top_bottom.py
+  16ab80b731aab6d8bb818525615d77c2d1fcb0c8  tac-qlib/tac_qlib/contrib/strategy/signal_quality_gate.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
+  316bf4aa160cc8d15929ea648be03f4b4999667d  tac-qlib/tac_qlib/data/__pycache__/__init__.cpython-312.pyc
-  99e602392d51663cb06d5c425000b1ed1e5a916b  tac-qlib/tac_qlib/data/__pycache__/config.cpython-312.pyc
+  554a3f29d181b64effbf49a8161b32e7f93d8d3e  tac-qlib/tac_qlib/data/__pycache__/config.cpython-312.pyc
-  020dcdcf288e4832c8cf2386351f78d5ceb4fe13  tac-qlib/tac_qlib/data/__pycache__/providers.cpython-312.pyc
+  8b47f6d78ac046b6b7b2fb07bd7f3382773ffb73  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/strategy/__init__.py

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

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

@@ -0,0 +1,117 @@
+"""Realized-IC circuit breaker TopkDropout strategy.
+
+Subclass of ``qlib.contrib.strategy.signal_strategy.TopkDropoutStrategy`` that
+holds the book (issues NO orders) while the streaming realized RankIC of the
+deployed signal is below threshold — i.e. the model's cross-sectional
+predictions are no longer earning against realized forward returns. When the
+gate is open it behaves exactly like the reference TopkDropoutStrategy.
+
+The gate is evaluated per trade step on the trailing mean realized RankIC of
+the signal over the last ``ic_window`` trading days whose label is fully
+realized as of the decision date (no lookahead — a 5d fwd label ``close[t+6]/
+close[t+1]-1`` is only known at ``t+6``).
+
+Two wiring modes:
+
+* ``ic_gate``: a precomputed ``pd.Series`` indexed by datetime of booleans
+  (True = gate open / trade allowed). Computed once by the caller (e.g.
+  ``rd_backtest``) and looked up per step. Missing dates default to open.
+* realized-IC self-computation: when ``ic_min_rankic`` is given but no
+  ``ic_gate``, the strategy computes the per-date realized RankIC itself from
+  ``self.signal`` (the pred scores) and the lake 1d bars via
+  ``tac_qlib.risk_limits.realized_rankic_series``, then applies the same
+  trailing-window comparison. Works when instantiated from a workflow YAML
+  PortAnaRecord config (``lake_root`` / ``market`` must be provided).
+"""
+
+from __future__ import annotations
+
+import pandas as pd
+
+from qlib.backtest.decision import TradeDecisionWO
+from qlib.contrib.strategy.signal_strategy import TopkDropoutStrategy
+
+from tac_qlib.risk_limits import ic_circuit_breaker, realized_rankic_series
+
+__all__ = ["ICGateTopkDropoutStrategy"]
+
+
+class ICGateTopkDropoutStrategy(TopkDropoutStrategy):
+    """TopkDropout with a streaming realized-IC circuit breaker.
+
+    Parameters
+    ----------
+    topk, n_drop, method_sell, method_buy, hold_thresh, only_tradable,
+    forbid_all_trade_at_limit : same as ``TopkDropoutStrategy``.
+    ic_min_rankic : float — pause new trading while trailing realized RankIC is
+        below this threshold (0 disables the gate).
+    ic_window : int — trailing window for the realized RankIC mean (default 22).
+    ic_label_horizon : int — label horizon in trading days (default 6).
+    ic_min_obs : int — min realized labels before the gate arms (default 10).
+    ic_gate : pd.Series, optional — precomputed per-date gate (bool indexed by
+        datetime). When provided, it overrides self-computation.
+    lake_root, market : str — lake location for self-computed realized IC.
+    """
+
+    def __init__(
+        self,
+        *,
+        topk,
+        n_drop,
+        ic_min_rankic: float = 0.0,
+        ic_window: int = 22,
+        ic_label_horizon: int = 6,
+        ic_min_obs: int = 10,
+        ic_gate=None,
+        lake_root: str = "",
+        market: str = "US",
+        **kwargs,
+    ):
+        super().__init__(topk=topk, n_drop=n_drop, **kwargs)
+        self.ic_min_rankic = float(ic_min_rankic or 0.0)
+        self.ic_window = int(ic_window or 22)
+        self.ic_label_horizon = int(ic_label_horizon or 6)
+        self.ic_min_obs = int(ic_min_obs or 10)
+        self._ic_gate = ic_gate
+        self._realized_ic = None
+        self.lake_root = lake_root or ""
+        self.market = market or "US"
+
+    def _load_realized_ic(self):
+        if self._realized_ic is None:
+            pred_start_time, pred_end_time = self.trade_calendar.get_step_time(
+                self.trade_calendar.get_trade_step(), shift=-self.ic_label_horizon
+            )
+            pred = self.signal.get_signal(start_time=pred_start_time, end_time=pred_end_time)
+            if isinstance(pred, pd.DataFrame):
+                pred = pred.iloc[:, 0]
+            self._realized_ic = realized_rankic_series(
+                pred, self.lake_root, self.market, label_horizon=self.ic_label_horizon
+            )
+        return self._realized_ic
+
+    def _gate_open(self, trade_start_time) -> bool:
+        ts = pd.Timestamp(trade_start_time)
+        if self._ic_gate is not None:
+            # precomputed gate series: look up the latest known decision date <= ts
+            known = self._ic_gate[self._ic_gate.index <= ts]
+            if len(known):
+                return bool(known.iloc[-1])
+            return True
+        if self.ic_min_rankic <= 0:
+            return True
+        realized = self._load_realized_ic()
+        limits = {
+            "ic_min_rankic": self.ic_min_rankic,
+            "ic_window": self.ic_window,
+            "ic_min_obs": self.ic_min_obs,
+        }
+        tripped, _reason, _trail = ic_circuit_breaker(realized, ts, limits)
+        return not tripped
+
+    def generate_trade_decision(self, execute_result=None):
+        trade_step = self.trade_calendar.get_trade_step()
+        trade_start_time, _ = self.trade_calendar.get_step_time(trade_step)
+        if not self._gate_open(trade_start_time):
+            return TradeDecisionWO([], self)
+        return super().generate_trade_decision(execute_result)

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/regime_gate.py

@@ -1,231 +1,215 @@
-"""HMM-regime overlay TopkDropout strategy.
+"""Regime-gate TopkDropout strategy.
 
-Regime-gate overlay on ``qlib.contrib.strategy.signal_strategy.TopkDropoutStrategy``:
+Subclass of ``qlib.contrib.strategy.signal_strategy.TopkDropoutStrategy`` that
-selection and sizing are identical to the reference, but a name is only BOUGHT
+holds the book (issues NO orders) while a regime detector says the market is in
-(entry gate) when its per-symbol HMM regime posterior ``sp_hmm_p_regime1`` on
+an unfavorable state.  When the gate is open it behaves exactly like the
-the signal date is >= ``regime_threshold``; otherwise it is held in cash instead
+reference TopkDropoutStrategy.
-of being opened.
 
-The regime posterior is read from the lake feature provider on the fly via
+Three detector types are supported (all causal — no lookahead):
-``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
+* ``dispersion``: cross-sectional standard deviation of 22-day rolling returns
-(entry gate only, matching the queue-10 design).
+  across the universe.  Gate closes when CS dispersion < threshold (low
+  dispersion means the spread between winners and losers is too narrow for
+  TopkDropout to exploit).
+* ``vol``: cross-sectional mean of 22-day rolling realized volatility.  Gate
+  closes when avg vol is outside a band ``[vol_low, vol_high]`` (strategy
+  needs moderate vol — too calm or too turbulent both hurt).
+* ``hmm``: pre-computed HMM posterior for regime 1 (``sp_hmm_p_regime1``).
+  Gate closes when posterior < threshold (model is not confident the calm
+  regime is active).
+
+The gate is provided as a precomputed ``pd.Series`` of booleans indexed by
+datetime (True = trade allowed).  The companion ``compute_regime_gate``
+function builds this series from lake bars; call it once before backtesting
+and pass the result as the ``regime_gate`` parameter.
 """
 
 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 TradeDecisionWO
-from qlib.backtest.decision import OrderDir, TradeDecisionWO
 from qlib.contrib.strategy.signal_strategy import TopkDropoutStrategy
 
-try:
+__all__ = ["RegimeGateTopkDropoutStrategy", "compute_regime_gate"]
-    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):
+class RegimeGateTopkDropoutStrategy(TopkDropoutStrategy):
-    """TopkDropout with an HMM-regime entry gate on buy candidates.
+    """TopkDropout with a regime-gate circuit breaker.
 
     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
+    regime_gate : pd.Series — precomputed per-date gate (bool indexed by
-        new position (default 0.5).
+        datetime).  True = trade allowed, False = no orders.  Missing dates
+        default to open (trade allowed).
     """
 
-    def __init__(self, *, topk, n_drop, regime_threshold: float = DEFAULT_REGIME_THRESHOLD, **kwargs):
+    def __init__(self, *, regime_gate=None, **kwargs):
-        super().__init__(topk=topk, n_drop=n_drop, **kwargs)
+        super().__init__(**kwargs)
-        self.regime_threshold = regime_threshold
+        self._regime_gate = regime_gate
 
-    def _regime_for(self, codes, pred_start, pred_end) -> pd.Series:
+    def _gate_open(self, trade_start_time) -> bool:
-        """Return {code: sp_hmm_p_regime1} for the signal window (last day)."""
+        if self._regime_gate is None:
-        if D is None:
+            return True
-            return pd.Series(dtype=float)
+        ts = pd.Timestamp(trade_start_time)
-        try:
+        known = self._regime_gate[self._regime_gate.index <= ts]
-            df = D.features(list(codes), [REGIME_FIELD], start_time=pred_start, end_time=pred_end, freq="day")
+        if len(known):
-        except Exception:  # noqa: BLE001 - a regime read failure should gate open, not crash
+            return bool(known.iloc[-1])
-            return pd.Series(dtype=float)
+        return True  # default open if no history yet
-        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)
+        trade_start_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)
+        if not self._gate_open(trade_start_time):
-        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)
+        return super().generate_trade_decision(execute_result)
 
-        if self.only_tradable:
 
-            def get_first_n(li, n, reverse=False):
+# ---------------------------------------------------------------------------
-                cur_n = 0
+# Precomputation helper
-                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):
+def compute_regime_gate(
-                return get_first_n(li, n, reverse=True)
+    detector: str,
+    threshold: float = 0.0,
+    *,
+    lake_root: str = "",
+    market: str = "US",
+    start: str = "2015-01-03",
+    end: str = "2026-08-19",
+    vol_low: float = 0.0,
+    vol_high: float = 999.0,
+    hmm_field: str = "sp_hmm_p_regime1",
+) -> pd.Series:
+    """Build a per-date regime gate series from lake bars.
 
-            def filter_stock(li):
+    Parameters
-                return [
+    ----------
-                    si
+    detector : str — ``"dispersion"``, ``"vol"``, or ``"hmm"``.
-                    for si in li
+    threshold : float — for ``dispersion``: min CS dispersion to allow trading.
-                    if self.trade_exchange.is_stock_tradable(
+        For ``hmm``: min HMM posterior to allow trading.
-                        stock_id=si, start_time=trade_start_time, end_time=trade_end_time
+        Ignored for ``vol`` (uses ``vol_low``/``vol_high`` band instead).
-                    )
+    lake_root, market : str — lake location.
-                ]
+    start, end : str — date window.
+    vol_low, vol_high : float — annualized vol band for the ``vol`` detector.
+    hmm_field : str — HMM feature column name for the ``hmm`` detector.
 
-        else:
+    Returns
+    -------
+    pd.Series — bool, indexed by datetime.  True = trade allowed.
+    """
+    from tac_qlib.data.config import LakeConfig, resolve_lake_root
 
-            def get_first_n(li, n):
+    cfg = LakeConfig(resolve_lake_root(lake_root or None), market)
-                return list(li)[:n]
+    symbols = _universe_symbols(cfg)
+    close_df, vol_df = _load_daily_bars(symbols, cfg, start, end)
+    if close_df.empty:
+        return pd.Series(dtype=bool)
 
-            def get_last_n(li, n):
+    if detector == "dispersion":
-                return list(li)[-n:]
+        return _dispersion_gate(close_df, threshold)
+    elif detector == "vol":
+        return _vol_gate(close_df, vol_low, vol_high)
+    elif detector == "hmm":
+        return _hmm_gate(cfg, symbols, threshold, start, end, hmm_field)
+    else:
+        raise ValueError(f"Unknown detector: {detector!r}")
 
-            def filter_stock(li):
-                return li
 
-        current_temp: "object" = copy.deepcopy(self.trade_position)
+def _universe_symbols(cfg) -> list:
-        sell_order_list: List[Order] = []
+    """Read symbols from the lake symbols.parquet."""
-        buy_order_list: List[Order] = []
+    import pathlib
-        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":
+    sp = cfg.lake_root / "symbols.parquet"
-            today = get_first_n(
+    if sp.exists():
-                pred_score[~pred_score.index.isin(last)].sort_values(ascending=False).index,
+        df = pd.read_parquet(sp)
-                self.n_drop + self.topk - len(last),
+        col = "symbol" if "symbol" in df.columns else df.columns[0]
-            )
+        return sorted(df[col].astype(str).str.upper().tolist())
-        elif self.method_buy == "random":
+    return []
-            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":
+def _load_daily_bars(symbols, cfg, start, end):
-            sell = last[last.isin(get_last_n(comb, self.n_drop))]
+    """Load daily close prices for all symbols into a wide DataFrame."""
-        elif self.method_sell == "random":
+    closes = {}
-            candi = filter_stock(last)
+    vols = {}
-            try:
+    for sym in symbols:
-                sell = pd.Index(np.random.choice(candi, self.n_drop, replace=False) if len(last) else [])
+        p = cfg.bar_path("1d", sym)
-            except ValueError:
+        if not p.exists():
-                sell = candi
+            continue
-        else:
+        try:
-            raise NotImplementedError(f"This type of input is not supported")
+            df = pd.read_parquet(p)
+        except Exception:
+            continue
+        if not len(df):
+            continue
+        tcol = df["t"] if "t" in df.columns else df["date"]
+        ts = pd.to_datetime(tcol)
+        df = df.assign(_t=ts).set_index("_t").sort_index()
+        df = df.loc[start:end]
+        if len(df) < 22:
+            continue
+        closes[sym] = df["c"]
+        if "v" in df.columns:
+            vols[sym] = df["v"]
+    close_df = pd.DataFrame(closes)
+    vol_df = pd.DataFrame(vols) if vols else None
+    return close_df, vol_df
 
-        buy = today[: len(sell) + self.topk - len(last)]
 
-        # ---- regime gate -----------------------------------------------------
+def _dispersion_gate(close_df, threshold):
-        if buy:
+    """Cross-sectional dispersion of 22-day rolling returns."""
-            regime = self._regime_for(buy, pred_start_time, pred_end_time)
+    if close_df.empty or close_df.shape[1] < 2:
-            gated = [c for c in buy if regime.get(c, np.nan) >= self.regime_threshold]
+        return pd.Series(dtype=bool)
-        else:
+    ret = close_df.pct_change(22)
-            gated = []
+    cs_disp = ret.std(axis=1)
+    gate = cs_disp >= threshold
+    gate.iloc[:22] = True  # warmup: allow trading
+    return gate
 
-        for code in current_stock_list:
+
-            if not self.trade_exchange.is_stock_tradable(
+def _vol_gate(close_df, vol_low, vol_high):
-                stock_id=code,
+    """Cross-sectional mean of 22-day rolling realized vol."""
-                start_time=trade_start_time,
+    if close_df.empty or close_df.shape[1] < 2:
-                end_time=trade_end_time,
+        return pd.Series(dtype=bool)
-                direction=None if self.forbid_all_trade_at_limit else OrderDir.SELL,
+    import numpy as np
-            ):
+    log_ret = np.log(close_df / close_df.shift(1))
+    rv22 = log_ret.rolling(22).std() * (252 ** 0.5)
+    cs_mean_vol = rv22.mean(axis=1)
+    gate = (cs_mean_vol >= vol_low) & (cs_mean_vol <= vol_high)
+    gate.iloc[:22] = True  # warmup
+    return gate
+
+
+def _hmm_gate(cfg, symbols, threshold, start, end, hmm_field):
+    """HMM regime posterior gate from persisted SP features."""
+    feat_root = cfg.lake_root / "features"
+    all_posteriors = {}
+    for sym in symbols:
+        # check both ta and sp family paths
+        for family in ("sp", "ta"):
+            p = feat_root / f"market=US" / f"timeframe=1d" / f"family={family}" / f"symbol={sym}.parquet"
+            if not p.exists():
                 continue
-            if code in sell:
+            try:
-                time_per_step = self.trade_calendar.get_freq()
+                df = pd.read_parquet(p)
-                if current_temp.get_stock_count(code, bar=time_per_step) < self.hold_thresh:
+            except Exception:
-                    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(
+            if hmm_field not in df.columns:
-                stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=OrderDir.BUY
+                continue
-            )
+            tcol = df["t"] if "t" in df.columns else df["date"]
-            buy_amount = value / buy_price
+            ts = pd.to_datetime(tcol)
-            factor = self.trade_exchange.get_factor(
+            s = pd.Series(df[hmm_field].values, index=ts, name=sym)
-                stock_id=code, start_time=trade_start_time, end_time=trade_end_time
+            s = s.loc[start:end].dropna()
-            )
+            if len(s) > 0:
-            buy_amount = self.trade_exchange.round_amount_by_trade_unit(buy_amount, factor)
+                all_posteriors[sym] = s
-            buy_order = Order(
+                break
-                stock_id=code,
+    if not all_posteriors:
-                amount=buy_amount,
+        # no HMM features found — default open
-                start_time=trade_start_time,
+        idx = pd.date_range(start, end, freq="B")
-                end_time=trade_end_time,
+        return pd.Series(True, index=idx)
-                direction=Order.BUY,
+    post_df = pd.DataFrame(all_posteriors)
-            )
+    cs_mean = post_df.mean(axis=1)
-            buy_order_list.append(buy_order)
+    gate = cs_mean >= threshold
-
+    return gate
-        return TradeDecisionWO(sell_order_list + buy_order_list, self)

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

@@ -0,0 +1,301 @@
+"""Signal-quality gate TopkDropout strategy.
+
+Subclass of ``qlib.contrib.strategy.signal_strategy.TopkDropoutStrategy`` that
+holds the book (issues NO orders) when the model's recent prediction accuracy
+is below a threshold.  When the gate is open it behaves exactly like the
+reference TopkDropoutStrategy.
+
+Unlike the regime gate (which asks "is the market calm?"), the signal-quality
+gate asks "are my predictions accurate?" — and works across ALL years.
+
+The gate is provided as a precomputed ``pd.Series`` of booleans indexed by
+datetime (True = trade allowed).  The companion ``compute_signal_quality_gate``
+function builds this series from a pred.pkl and lake bars; call it once before
+backtesting and pass the result as the ``signal_quality_gate`` parameter.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from qlib.backtest.decision import TradeDecisionWO
+from qlib.contrib.strategy.signal_strategy import TopkDropoutStrategy
+
+__all__ = ["SignalQualityGateStrategy", "compute_signal_quality_gate"]
+
+
+class SignalQualityGateStrategy(TopkDropoutStrategy):
+    """TopkDropout with signal-quality gate overlay.
+
+    When ``lake_root`` is provided the gate is computed on-the-fly from the
+    signal (``<PRED>``) and close prices — no precomputed gate file needed.
+    This ensures the gate matches the model that is actually generating the
+    predictions (critical when the model is retrained each year).
+
+    Parameters
+    ----------
+    topk, n_drop, method_sell, method_buy, hold_thresh, only_tradable,
+    forbid_all_trade_at_limit : same as ``TopkDropoutStrategy``.
+    signal_quality_gate : pd.Series — precomputed per-date gate (bool).
+    signal_quality_gate_path : str — path to pickled gate Series.
+    lake_root : str — lake root for on-the-fly gate computation (preferred).
+    gate_topk, gate_lookback, gate_threshold : int/float — gate params.
+    gate_start, gate_end : str — date window for loading close prices.
+    """
+
+    def __init__(self, *, signal_quality_gate=None, signal_quality_gate_path=None,
+                 lake_root=None, gate_topk=10, gate_lookback=5, gate_threshold=0.5,
+                 gate_start="2015-01-03", gate_end="2026-08-19", **kwargs):
+        super().__init__(**kwargs)
+        self._sq_gate_computed = False
+        if signal_quality_gate is not None:
+            self._sq_gate = signal_quality_gate
+            self._sq_gate_computed = True
+        elif signal_quality_gate_path is not None:
+            import pickle
+            with open(signal_quality_gate_path, "rb") as f:
+                self._sq_gate = pickle.load(f)
+            self._sq_gate_computed = True
+        elif lake_root is not None:
+            self._sq_gate = None
+            self._lake_root = lake_root
+            self._gate_topk = gate_topk
+            self._gate_lookback = gate_lookback
+            self._gate_threshold = gate_threshold
+            self._gate_start = gate_start
+            self._gate_end = gate_end
+        else:
+            self._sq_gate = None
+
+    def _compute_gate_on_fly(self):
+        """Compute gate from the signal (pred.pkl) and lake close prices."""
+        import pickle
+        from pathlib import Path
+
+        signal_path = self._signal
+        if not Path(signal_path).exists():
+            return
+
+        with open(signal_path, "rb") as f:
+            pred = pickle.load(f)
+
+        # Handle MultiIndex DataFrame -> unstack to wide
+        if isinstance(pred, pd.DataFrame) and isinstance(pred.index, pd.MultiIndex):
+            pred = pred.iloc[:, 0]
+            pred.index = pd.MultiIndex.from_arrays([
+                pd.to_datetime(pred.index.get_level_values(0)).normalize(),
+                pred.index.get_level_values(1)
+            ])
+            pred = pred.unstack(level=1)
+        elif isinstance(pred, pd.DataFrame):
+            pred = pred.iloc[:, 0] if pred.shape[1] >= 1 else pred.squeeze()
+            pred.index = pd.to_datetime(pred.index).normalize()
+
+        # Load close prices from lake
+        close_df = _load_close_prices(self._lake_root, "US", self._gate_start, self._gate_end)
+        if close_df.empty:
+            return
+
+        ret_df = close_df.pct_change()
+        ret_df.index = pd.to_datetime(ret_df.index).normalize()
+
+        pred_dates = sorted(pred.index.unique())
+        if len(pred_dates) < 2:
+            self._sq_gate = pd.Series(True, index=pd.DatetimeIndex(pred_dates))
+            self._sq_gate_computed = True
+            return
+
+        hit_rates = {}
+        for i in range(1, len(pred_dates)):
+            day = pred_dates[i]
+            prev_day = pred_dates[i - 1]
+            try:
+                prev_scores = pred.loc[prev_day]
+            except KeyError:
+                continue
+            if isinstance(prev_scores, pd.DataFrame):
+                prev_scores = prev_scores.iloc[:, 0]
+            prev_scores = prev_scores.dropna().sort_values(ascending=False)
+            topk_syms = list(prev_scores.index[:self._gate_topk])
+
+            if day not in ret_df.index:
+                continue
+            today_ret = ret_df.loc[day]
+            topk_rets = today_ret.reindex(topk_syms).dropna()
+            if len(topk_rets) == 0:
+                continue
+
+            hit_rates[day] = (topk_rets > 0).sum() / len(topk_rets)
+
+        if not hit_rates:
+            self._sq_gate_computed = True
+            return
+
+        hr_series = pd.Series(hit_rates).sort_index()
+        rolling_hr = hr_series.rolling(self._gate_lookback, min_periods=1).mean()
+        gate = rolling_hr >= self._gate_threshold
+        gate.iloc[:self._gate_lookback] = True
+
+        self._sq_gate = gate
+        self._sq_gate_computed = True
+
+    def _gate_open(self, trade_start_time) -> bool:
+        if self._sq_gate is None:
+            return True
+        ts = pd.Timestamp(trade_start_time)
+        known = self._sq_gate[self._sq_gate.index <= ts]
+        if len(known):
+            return bool(known.iloc[-1])
+        return True  # default open if no history yet
+
+    def generate_trade_decision(self, execute_result=None):
+        if not self._sq_gate_computed:
+            self._compute_gate_on_fly()
+        trade_step = self.trade_calendar.get_trade_step()
+        trade_start_time, _ = self.trade_calendar.get_step_time(trade_step)
+        if not self._gate_open(trade_start_time):
+            return TradeDecisionWO([], self)
+        return super().generate_trade_decision(execute_result)
+
+
+# ---------------------------------------------------------------------------
+# Precomputation helper
+# ---------------------------------------------------------------------------
+
+def compute_signal_quality_gate(
+    pred_path: str,
+    *,
+    lake_root: str = "",
+    market: str = "US",
+    topk: int = 10,
+    lookback: int = 5,
+    threshold: float = 0.5,
+    start: str = "2015-01-03",
+    end: str = "2026-08-19",
+) -> pd.Series:
+    """Build a per-date signal-quality gate series from a pred.pkl and lake bars.
+
+    For each day, checks whether the model's topk picks from the previous day
+    had positive returns.  Computes a rolling hit rate over ``lookback`` days
+    and opens the gate when hit rate >= ``threshold``.
+
+    Parameters
+    ----------
+    pred_path : str — path to pred.pkl (from rd_train / rd_predict).
+    lake_root, market : str — lake location (for loading close prices).
+    topk : int — number of top picks to track for hit rate.
+    lookback : int — rolling window for hit rate computation.
+    threshold : float — hit rate threshold to keep trading.
+    start, end : str — date window for loading prices.
+
+    Returns
+    -------
+    pd.Series — bool, indexed by datetime.  True = trade allowed.
+    """
+    from pathlib import Path
+    import pickle
+
+    # Load pred.pkl
+    with open(pred_path, "rb") as f:
+        pred = pickle.load(f)
+
+    # Handle MultiIndex DataFrame (datetime, instrument) -> unstack to wide
+    if isinstance(pred, pd.DataFrame) and isinstance(pred.index, pd.MultiIndex):
+        pred = pred.iloc[:, 0]  # take score column as Series
+        pred.index = pd.MultiIndex.from_arrays([
+            pd.to_datetime(pred.index.get_level_values(0)).normalize(),
+            pred.index.get_level_values(1)
+        ])
+        # Unstack to wide: dates x instruments
+        pred = pred.unstack(level=1)
+    elif isinstance(pred, pd.DataFrame):
+        pred = pred.iloc[:, 0] if pred.shape[1] >= 1 else pred.squeeze()
+        pred.index = pd.to_datetime(pred.index).normalize()
+
+    # Load close prices from lake
+    close_df = _load_close_prices(lake_root, market, start, end)
+    if close_df.empty:
+        return pd.Series(dtype=bool)
+
+    ret_df = close_df.pct_change()
+    ret_df.index = pd.to_datetime(ret_df.index).normalize()
+
+    # Get sorted unique prediction dates
+    pred_dates = sorted(pred.index.unique())
+    if len(pred_dates) < 2:
+        return pd.Series(True, index=pd.DatetimeIndex(pred_dates))
+
+    # Compute hit rates
+    hit_rates = {}
+    for i in range(1, len(pred_dates)):
+        day = pred_dates[i]
+        # Get yesterday's topk
+        prev_day = pred_dates[i - 1]
+        try:
+            prev_scores = pred.loc[prev_day]
+        except KeyError:
+            continue
+        if isinstance(prev_scores, pd.DataFrame):
+            prev_scores = prev_scores.iloc[:, 0]
+        prev_scores = prev_scores.dropna().sort_values(ascending=False)
+        topk_syms = list(prev_scores.index[:topk])
+
+        # Get today's returns
+        if day not in ret_df.index:
+            continue
+        today_ret = ret_df.loc[day]
+        topk_rets = today_ret.reindex(topk_syms).dropna()
+        if len(topk_rets) == 0:
+            continue
+
+        hit_rates[day] = (topk_rets > 0).sum() / len(topk_rets)
+
+    if not hit_rates:
+        return pd.Series(dtype=bool)
+
+    hr_series = pd.Series(hit_rates).sort_index()
+
+    # Rolling hit rate
+    rolling_hr = hr_series.rolling(lookback, min_periods=1).mean()
+
+    # Gate is open when rolling hit rate >= threshold
+    gate = rolling_hr >= threshold
+    gate.iloc[:lookback] = True  # warmup: allow trading
+
+    return gate
+
+
+def _load_close_prices(lake_root, market, start, end):
+    """Load daily close prices for all symbols into a wide DataFrame."""
+    from pathlib import Path
+
+    lake = Path(lake_root)
+    symbols_parquet = lake / "symbols.parquet"
+    if not symbols_parquet.exists():
+        return pd.DataFrame()
+
+    df = pd.read_parquet(symbols_parquet)
+    col = "symbol" if "symbol" in df.columns else df.columns[0]
+    symbols = sorted(df[col].astype(str).str.upper().tolist())
+
+    closes = {}
+    for sym in symbols:
+        p = lake / "market=US" / "timeframe=1d" / f"symbol={sym}.parquet"
+        if not p.exists():
+            continue
+        try:
+            bar = pd.read_parquet(p)
+        except Exception:
+            continue
+        if not len(bar):
+            continue
+        tcol = "t" if "t" in bar.columns else "date"
+        ts = pd.to_datetime(bar[tcol])
+        bar = bar.assign(_t=ts).set_index("_t").sort_index()
+        bar = bar.loc[start:end]
+        if len(bar) < 10:
+            continue
+        closes[sym] = bar["c"] if "c" in bar.columns else bar["close"]
+
+    return pd.DataFrame(closes)

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)

evidence/q08-risklimit/RESULT.md

@@ -1,35 +0,0 @@
-# Q08 — Risk-limit A/B re-validation (trace 40)
-
-**Status:** DONE (verdict: REFUTED as an IR edge; safety-net value retained)
-
-## Input
-- Reference signal: exp-26 pred, run `21afc6afdb674a399b59dd76c97628ce` (mlflow exp 25)
-- Window: 2026-01-04 → 2026-08-10, Topk10 n_drop1, SPY benchmark, $1M, 5/15bp/$5
-- Tool: `rd_risk_calibrate` (A/B + sensitivity grid). Full JSON: `risk_calibration.json`
-
-## Candidate spec (round-3 live spec)
-`{"liquidity_floor_adv": 5000000, "size_cap_pct": 0.12, "concentration_cap_pct": 0.95, "drawdown_pause_pct": 0.10}`
-
-## Results (net, with cost)
-| Config | IR | Ann. return | Max DD |
-|---|---|---|---|
-| baseline (no limits) | 1.5804 | +27.50% | −6.91% |
-| **candidate (5M floor + caps)** | **1.5121** | +2.20% | **−0.65%** |
-| liquidity $10M | 1.5457 | +2.25% | −0.64% |
-
-## Findings
-- **Floor binds, not a no-op**: $5M liquidity floor dropped 8 symbols —
-  `DBA, DBC, ESPO, FDN, REM, TAN, UNG, XAR`.
-- **No IR edge from the gate**: candidate IR (1.512) is BELOW baseline (1.580).
-  The exp-18 direction (floor IR 0.81→0.98) does NOT reproduce on the clean-lake
-  reference signal.
-- **Drawdown cut is pure defunding**: size_cap 0.12 × concentration 0.95 fold
-  the effective risk_degree to ~0.0095 → ~$9.5k deployed of $1M (~100x less).
-  Sensitivity grid shows both caps are no-ops (conc 20–50% identical,
-  size_cap 5–20% identical); only the liquidity floor moves returns, marginally.
-- **Conclusion**: keep the live spec as a safety net; there is no risk-limit
-  gate IR edge to harvest when the signal is the bottleneck (exp-20 pattern).
-
-## Artifacts on this branch
-- `evidence/q08-risklimit/risk_calibration.json` — full calibration dump
-- `queue/designs/q08_risk_limit_ab.md` — the pre-registered design doc

evidence/q08-risklimit/risk_calibration.json

@@ -1,401 +0,0 @@
-{
-  "rows": [
-    {
-      "label": "baseline (no limits)",
-      "mean": 0.001155,
-      "std": 0.011279,
-      "annualized_return": 0.274989,
-      "information_ratio": 1.580427,
-      "max_drawdown": -0.069145
-    },
-    {
-      "label": "liquidity $10,000,000",
-      "mean": 9.4e-05,
-      "std": 0.000942,
-      "annualized_return": 0.022464,
-      "information_ratio": 1.545736,
-      "max_drawdown": -0.006389
-    },
-    {
-      "label": "conc 20%",
-      "mean": 0.000115,
-      "std": 0.001168,
-      "annualized_return": 0.027285,
-      "information_ratio": 1.513718,
-      "max_drawdown": -0.008104
-    },
-    {
-      "label": "conc 30%",
-      "mean": 0.000115,
-      "std": 0.001168,
-      "annualized_return": 0.027285,
-      "information_ratio": 1.513718,
-      "max_drawdown": -0.008104
-    },
-    {
-      "label": "conc 40%",
-      "mean": 0.000115,
-      "std": 0.001168,
-      "annualized_return": 0.027285,
-      "information_ratio": 1.513718,
-      "max_drawdown": -0.008104
-    },
-    {
-      "label": "conc 50%",
-      "mean": 0.000115,
-      "std": 0.001168,
-      "annualized_return": 0.027285,
-      "information_ratio": 1.513718,
-      "max_drawdown": -0.008104
-    },
-    {
-      "label": "candidate {\"liquidity_floor_adv\": 5000000.0, \"size_cap_pct\": 0.12, \"concentration_cap_pct\": 0.95, \"drawdown_pause_pct\": 0.1}",
-      "mean": 9.2e-05,
-      "std": 0.000943,
-      "annualized_return": 0.021991,
-      "information_ratio": 1.512051,
-      "max_drawdown": -0.00653
-    },
-    {
-      "label": "size_cap 5%",
-      "mean": 9.2e-05,
-      "std": 0.000943,
-      "annualized_return": 0.021991,
-      "information_ratio": 1.512051,
-      "max_drawdown": -0.00653
-    },
-    {
-      "label": "size_cap 10%",
-      "mean": 9.2e-05,
-      "std": 0.000943,
-      "annualized_return": 0.021991,
-      "information_ratio": 1.512051,
-      "max_drawdown": -0.00653
-    },
-    {
-      "label": "size_cap 15%",
-      "mean": 9.2e-05,
-      "std": 0.000943,
-      "annualized_return": 0.021991,
-      "information_ratio": 1.512051,
-      "max_drawdown": -0.00653
-    },
-    {
-      "label": "size_cap 20%",
-      "mean": 9.2e-05,
-      "std": 0.000943,
-      "annualized_return": 0.021991,
-      "information_ratio": 1.512051,
-      "max_drawdown": -0.00653
-    },
-    {
-      "label": "liquidity $5,000,000",
-      "mean": 9.2e-05,
-      "std": 0.000943,
-      "annualized_return": 0.021991,
-      "information_ratio": 1.512051,
-      "max_drawdown": -0.00653
-    },
-    {
-      "label": "liquidity $1,000,000",
-      "mean": 9.1e-05,
-      "std": 0.000929,
-      "annualized_return": 0.021625,
-      "information_ratio": 1.508748,
-      "max_drawdown": -0.006376
-    },
-    {
-      "label": "liquidity $2,500,000",
-      "mean": 7.1e-05,
-      "std": 0.000918,
-      "annualized_return": 0.017,
-      "information_ratio": 1.199721,
-      "max_drawdown": -0.007158
-    }
-  ],
-  "runs": {
-    "baseline": {
-      "risk": {
-        "mean": 0.0011554172081987572,
-        "std": 0.01127853762493476,
-        "annualized_return": 0.27498929555130425,
-        "information_ratio": 1.5804272791471323,
-        "max_drawdown": -0.06914515336341577
-      },
-      "applied": {}
-    },
-    "candidate": {
-      "risk": {
-        "mean": 9.239707947451976e-05,
-        "std": 0.0009427144352738658,
-        "annualized_return": 0.0219905049149357,
-        "information_ratio": 1.5120514373488407,
-        "max_drawdown": -0.006530482262119444
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "FDN",
-          "REM",
-          "TAN",
-          "UNG",
-          "XAR"
-        ]
-      }
-    },
-    "size_cap 5%": {
-      "risk": {
-        "mean": 9.239707947451976e-05,
-        "std": 0.0009427144352738658,
-        "annualized_return": 0.0219905049149357,
-        "information_ratio": 1.5120514373488407,
-        "max_drawdown": -0.006530482262119444
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "FDN",
-          "REM",
-          "TAN",
-          "UNG",
-          "XAR"
-        ]
-      }
-    },
-    "size_cap 10%": {
-      "risk": {
-        "mean": 9.239707947451976e-05,
-        "std": 0.0009427144352738658,
-        "annualized_return": 0.0219905049149357,
-        "information_ratio": 1.5120514373488407,
-        "max_drawdown": -0.006530482262119444
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "FDN",
-          "REM",
-          "TAN",
-          "UNG",
-          "XAR"
-        ]
-      }
-    },
-    "size_cap 15%": {
-      "risk": {
-        "mean": 9.239707947451976e-05,
-        "std": 0.0009427144352738658,
-        "annualized_return": 0.0219905049149357,
-        "information_ratio": 1.5120514373488407,
-        "max_drawdown": -0.006530482262119444
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "FDN",
-          "REM",
-          "TAN",
-          "UNG",
-          "XAR"
-        ]
-      }
-    },
-    "size_cap 20%": {
-      "risk": {
-        "mean": 9.239707947451976e-05,
-        "std": 0.0009427144352738658,
-        "annualized_return": 0.0219905049149357,
-        "information_ratio": 1.5120514373488407,
-        "max_drawdown": -0.006530482262119444
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "FDN",
-          "REM",
-          "TAN",
-          "UNG",
-          "XAR"
-        ]
-      }
-    },
-    "conc 20%": {
-      "risk": {
-        "mean": 0.00011464156491316718,
-        "std": 0.0011683839517000441,
-        "annualized_return": 0.027284692449333788,
-        "information_ratio": 1.5137180903503433,
-        "max_drawdown": -0.008103887185240407
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "FDN",
-          "REM",
-          "TAN",
-          "UNG",
-          "XAR"
-        ]
-      }
-    },
-    "conc 30%": {
-      "risk": {
-        "mean": 0.00011464156491316718,
-        "std": 0.0011683839517000441,
-        "annualized_return": 0.027284692449333788,
-        "information_ratio": 1.5137180903503433,
-        "max_drawdown": -0.008103887185240407
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "FDN",
-          "REM",
-          "TAN",
-          "UNG",
-          "XAR"
-        ]
-      }
-    },
-    "conc 40%": {
-      "risk": {
-        "mean": 0.00011464156491316718,
-        "std": 0.0011683839517000441,
-        "annualized_return": 0.027284692449333788,
-        "information_ratio": 1.5137180903503433,
-        "max_drawdown": -0.008103887185240407
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "FDN",
-          "REM",
-          "TAN",
-          "UNG",
-          "XAR"
-        ]
-      }
-    },
-    "conc 50%": {
-      "risk": {
-        "mean": 0.00011464156491316718,
-        "std": 0.0011683839517000441,
-        "annualized_return": 0.027284692449333788,
-        "information_ratio": 1.5137180903503433,
-        "max_drawdown": -0.008103887185240407
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "FDN",
-          "REM",
-          "TAN",
-          "UNG",
-          "XAR"
-        ]
-      }
-    },
-    "liquidity $1,000,000": {
-      "risk": {
-        "mean": 9.086210454881382e-05,
-        "std": 0.0009290831160004576,
-        "annualized_return": 0.021625180882617688,
-        "information_ratio": 1.508747982736451,
-        "max_drawdown": -0.006376134679664126
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "ESPO"
-        ]
-      }
-    },
-    "liquidity $2,500,000": {
-      "risk": {
-        "mean": 7.142665167642606e-05,
-        "std": 0.0009184775632266332,
-        "annualized_return": 0.016999543098989402,
-        "information_ratio": 1.1997208834083914,
-        "max_drawdown": -0.0071582979845040825
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "REM",
-          "XAR"
-        ]
-      }
-    },
-    "liquidity $5,000,000": {
-      "risk": {
-        "mean": 9.239707947451976e-05,
-        "std": 0.0009427144352738658,
-        "annualized_return": 0.0219905049149357,
-        "information_ratio": 1.5120514373488407,
-        "max_drawdown": -0.006530482262119444
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "FDN",
-          "REM",
-          "TAN",
-          "UNG",
-          "XAR"
-        ]
-      }
-    },
-    "liquidity $10,000,000": {
-      "risk": {
-        "mean": 9.438545151345752e-05,
-        "std": 0.0009420158170657147,
-        "annualized_return": 0.02246373746020289,
-        "information_ratio": 1.5457360696934006,
-        "max_drawdown": -0.006388809561209335
-      },
-      "applied": {
-        "dropped_liquidity": [
-          "DBA",
-          "DBC",
-          "ESPO",
-          "FDN",
-          "ICLN",
-          "ITA",
-          "MDY",
-          "REM",
-          "SHY",
-          "TAN",
-          "UNG",
-          "XAR"
-        ]
-      }
-    }
-  },
-  "candidate": {
-    "liquidity_floor_adv": 5000000.0,
-    "size_cap_pct": 0.12,
-    "concentration_cap_pct": 0.95,
-    "drawdown_pause_pct": 0.1
-  }
-}

queue/designs/q08_risk_limit_ab.md

@@ -1,34 +0,0 @@
-# QUEUE-08 — Risk-limit A/B re-validation: $5M liquidity floor on the exp-26 reference
-
-**Status:** QUEUED · **Priority:** P1 · **Effort:** tool-only (no new code)
-
-## Hypothesis (prove)
-The $5M liquidity floor improves net IR and cuts drawdown on the **post-reset**
-reference signal (pre-reset exp 18, EVIDENCE#008: net IR 0.81→0.98, cumDD
-7.93%→5.44%), while size/concentration caps hurt by cutting deployed capital.
-Needs re-validation on the exp-26 lineage because exp 18 is pre-clean-lake and
-not comparable (EVIDENCE#009/010). Source: `book/CLAIMS.md` open question +
-`book/README.md` `TODO(evidence-needed: reconciliation of exp 18 risk-limit spec
-on the post-reset reference signal)`.
-
-## Change vs exp-26 reference (ONE variable)
-- Reference: the saved exp-26 prediction (run `21afc6af…`, mlflow exp 25).
-- A/B via `rd_risk_calibrate` (runs limit-vs-no-limit A/B + sensitivity grid
-  over size_cap_pct, concentration_cap_pct, liquidity_floor_adv) and/or
-  `rd_backtest` with `risk_limits` on the SAME saved `pred.pkl`:
-  - baseline: no limits (this must reproduce the exp-26 net +2.13% / IR 0.21);
-  - candidate: `{"liquidity_floor_adv": 5000000, "size_cap_pct": 0.12,
-    "concentration_cap_pct": 0.95, "drawdown_pause_pct": 0.10}` (round-3 spec).
-- Pick the spec (B2 calibration) that keeps live ≈ backtest.
-
-## Acceptance
-- Candidate spec: `net_IR > 0.21` AND `net_max_drawdown < 7.69%` vs no-limit on
-  the same pred. Size/concentration caps expected to REDUCE deployed capital
-  (record the direction as confirmation of exp 18).
-- If the floor is a no-op (gates don't bind at this signal) → report that gates
-  are no-ops when the signal is the bottleneck (exp 20 pattern) as a PROVEN
-  clean-lake result.
-
-## Execution prerequisites
-- None (uses saved pred + `rd_risk_calibrate`/`rd_backtest`). Trace the A/B as
-  an experiment; record the spec chosen for the next live round.