finish experiment 57 (exp/57-signal-quality-gate-gate-trades-based-on)

book/data/signal_quality_gate/signal_quality_gate_results.csv

@@ -0,0 +1,46 @@
+window,gate,start,end,trade_dates,gate_open,gate_closed,trip_rate,base_ann,base_sharpe,base_maxDD,gated_ann,gated_sharpe,gated_maxDD
+2026,hitrate_5d_0.50,2026-01-04,2026-08-19,157,92,65,0.414,0.255023,1.4465,-0.080671,0.649911,5.7351,-0.031795
+2026,hitrate_5d_0.60,2026-01-04,2026-08-19,157,49,108,0.6879,0.255023,1.4465,-0.080671,0.489313,6.0111,-0.014864
+2026,hitrate_5d_0.70,2026-01-04,2026-08-19,157,15,142,0.9045,0.255023,1.4465,-0.080671,0.229523,4.3611,-0.002029
+2026,hitrate_10d_0.50,2026-01-04,2026-08-19,157,109,48,0.3057,0.255023,1.4465,-0.080671,0.335822,2.6391,-0.060142
+2026,hitrate_10d_0.60,2026-01-04,2026-08-19,157,36,121,0.7707,0.255023,1.4465,-0.080671,0.251108,3.8579,-0.026842
+2026,hitrate_10d_0.70,2026-01-04,2026-08-19,157,9,148,0.9427,0.255023,1.4465,-0.080671,0.039314,1.3415,-0.012061
+2026,hitrate_20d_0.40,2026-01-04,2026-08-19,157,157,0,0.0,0.255023,1.4465,-0.080671,0.255023,1.4465,-0.080671
+2026,hitrate_20d_0.50,2026-01-04,2026-08-19,157,118,39,0.2484,0.255023,1.4465,-0.080671,0.343819,2.5185,-0.06259
+2026,hitrate_20d_0.60,2026-01-04,2026-08-19,157,28,129,0.8217,0.255023,1.4465,-0.080671,0.020214,0.3601,-0.028489
+2025,hitrate_5d_0.50,2025-01-02,2025-12-31,250,153,97,0.388,0.177515,0.8573,-0.217417,0.72055,6.9599,-0.048495
+2025,hitrate_5d_0.60,2025-01-02,2025-12-31,250,90,160,0.64,0.177515,0.8573,-0.217417,0.48564,5.3623,-0.046673
+2025,hitrate_5d_0.70,2025-01-02,2025-12-31,250,39,211,0.844,0.177515,0.8573,-0.217417,0.249221,4.9448,-0.009619
+2025,hitrate_10d_0.50,2025-01-02,2025-12-31,250,170,80,0.32,0.177515,0.8573,-0.217417,0.435847,3.5614,-0.055776
+2025,hitrate_10d_0.60,2025-01-02,2025-12-31,250,66,184,0.736,0.177515,0.8573,-0.217417,0.324574,5.2279,-0.016028
+2025,hitrate_10d_0.70,2025-01-02,2025-12-31,250,14,236,0.944,0.177515,0.8573,-0.217417,0.043002,1.4635,-0.010154
+2025,hitrate_20d_0.40,2025-01-02,2025-12-31,250,247,3,0.012,0.177515,0.8573,-0.217417,0.202949,0.9896,-0.217417
+2025,hitrate_20d_0.50,2025-01-02,2025-12-31,250,177,73,0.292,0.177515,0.8573,-0.217417,0.340772,2.8303,-0.071731
+2025,hitrate_20d_0.60,2025-01-02,2025-12-31,250,48,202,0.808,0.177515,0.8573,-0.217417,0.266028,4.1749,-0.021527
+2024,hitrate_5d_0.50,2024-01-02,2024-12-31,253,139,114,0.4506,0.08229,0.5594,-0.10685,0.30351,2.4275,-0.088219
+2024,hitrate_5d_0.60,2024-01-02,2024-12-31,253,71,182,0.7194,0.08229,0.5594,-0.10685,0.265365,2.4908,-0.078304
+2024,hitrate_5d_0.70,2024-01-02,2024-12-31,253,19,234,0.9249,0.08229,0.5594,-0.10685,0.143125,3.377,-0.003364
+2024,hitrate_10d_0.50,2024-01-02,2024-12-31,253,157,96,0.3794,0.08229,0.5594,-0.10685,0.277421,2.5767,-0.043146
+2024,hitrate_10d_0.60,2024-01-02,2024-12-31,253,37,216,0.8538,0.08229,0.5594,-0.10685,0.207161,3.6083,-0.011122
+2024,hitrate_10d_0.70,2024-01-02,2024-12-31,253,7,246,0.9723,0.08229,0.5594,-0.10685,0.031785,1.7408,-0.002083
+2024,hitrate_20d_0.40,2024-01-02,2024-12-31,253,247,6,0.0237,0.08229,0.5594,-0.10685,0.078007,0.5342,-0.10685
+2024,hitrate_20d_0.50,2024-01-02,2024-12-31,253,177,76,0.3004,0.08229,0.5594,-0.10685,0.210672,1.8469,-0.056207
+2024,hitrate_20d_0.60,2024-01-02,2024-12-31,253,13,240,0.9486,0.08229,0.5594,-0.10685,0.005953,0.3039,-0.014443
+2023,hitrate_5d_0.50,2023-01-03,2023-12-29,250,139,111,0.444,-0.047644,-0.2738,-0.197856,0.546654,4.2124,-0.035676
+2023,hitrate_5d_0.60,2023-01-03,2023-12-29,250,79,171,0.684,-0.047644,-0.2738,-0.197856,0.556291,5.1026,-0.025449
+2023,hitrate_5d_0.70,2023-01-03,2023-12-29,250,34,216,0.864,-0.047644,-0.2738,-0.197856,0.404269,4.4477,-0.013842
+2023,hitrate_10d_0.50,2023-01-03,2023-12-29,250,148,102,0.408,-0.047644,-0.2738,-0.197856,0.459869,3.5211,-0.046921
+2023,hitrate_10d_0.60,2023-01-03,2023-12-29,250,62,188,0.752,-0.047644,-0.2738,-0.197856,0.368232,4.0148,-0.022983
+2023,hitrate_10d_0.70,2023-01-03,2023-12-29,250,13,237,0.948,-0.047644,-0.2738,-0.197856,0.091481,2.1324,-0.010866
+2023,hitrate_20d_0.40,2023-01-03,2023-12-29,250,237,13,0.052,-0.047644,-0.2738,-0.197856,0.06639,0.3895,-0.146704
+2023,hitrate_20d_0.50,2023-01-03,2023-12-29,250,149,101,0.404,-0.047644,-0.2738,-0.197856,0.366016,2.5969,-0.063998
+2023,hitrate_20d_0.60,2023-01-03,2023-12-29,250,40,210,0.84,-0.047644,-0.2738,-0.197856,0.149844,2.2645,-0.032267
+2021,hitrate_5d_0.50,2021-01-04,2021-12-31,252,145,107,0.4246,0.18367,1.0979,-0.102651,0.556615,5.9167,-0.028062
+2021,hitrate_5d_0.60,2021-01-04,2021-12-31,252,68,184,0.7302,0.18367,1.0979,-0.102651,0.351867,5.8468,-0.011638
+2021,hitrate_5d_0.70,2021-01-04,2021-12-31,252,26,226,0.8968,0.18367,1.0979,-0.102651,0.148417,3.9593,-0.0041
+2021,hitrate_10d_0.50,2021-01-04,2021-12-31,252,163,89,0.3532,0.18367,1.0979,-0.102651,0.465023,4.2342,-0.040569
+2021,hitrate_10d_0.60,2021-01-04,2021-12-31,252,51,201,0.7976,0.18367,1.0979,-0.102651,0.21802,4.7978,-0.011134
+2021,hitrate_10d_0.70,2021-01-04,2021-12-31,252,13,239,0.9484,0.18367,1.0979,-0.102651,0.06108,2.7055,-0.000262
+2021,hitrate_20d_0.40,2021-01-04,2021-12-31,252,252,0,0.0,0.18367,1.0979,-0.102651,0.18367,1.0979,-0.102651
+2021,hitrate_20d_0.50,2021-01-04,2021-12-31,252,166,86,0.3413,0.18367,1.0979,-0.102651,0.289756,2.5787,-0.049244
+2021,hitrate_20d_0.60,2021-01-04,2021-12-31,252,38,214,0.8492,0.18367,1.0979,-0.102651,0.104685,2.394,-0.015084

book/data/signal_quality_gate/signal_quality_gate_results.json

@@ -0,0 +1,722 @@
+[
+  {
+    "window": "2026",
+    "gate": "hitrate_5d_0.50",
+    "start": "2026-01-04",
+    "end": "2026-08-19",
+    "trade_dates": 157,
+    "gate_open": 92,
+    "gate_closed": 65,
+    "trip_rate": 0.414,
+    "base_ann": 0.255023,
+    "base_sharpe": 1.4465,
+    "base_maxDD": -0.080671,
+    "gated_ann": 0.649911,
+    "gated_sharpe": 5.7351,
+    "gated_maxDD": -0.031795
+  },
+  {
+    "window": "2026",
+    "gate": "hitrate_5d_0.60",
+    "start": "2026-01-04",
+    "end": "2026-08-19",
+    "trade_dates": 157,
+    "gate_open": 49,
+    "gate_closed": 108,
+    "trip_rate": 0.6879,
+    "base_ann": 0.255023,
+    "base_sharpe": 1.4465,
+    "base_maxDD": -0.080671,
+    "gated_ann": 0.489313,
+    "gated_sharpe": 6.0111,
+    "gated_maxDD": -0.014864
+  },
+  {
+    "window": "2026",
+    "gate": "hitrate_5d_0.70",
+    "start": "2026-01-04",
+    "end": "2026-08-19",
+    "trade_dates": 157,
+    "gate_open": 15,
+    "gate_closed": 142,
+    "trip_rate": 0.9045,
+    "base_ann": 0.255023,
+    "base_sharpe": 1.4465,
+    "base_maxDD": -0.080671,
+    "gated_ann": 0.229523,
+    "gated_sharpe": 4.3611,
+    "gated_maxDD": -0.002029
+  },
+  {
+    "window": "2026",
+    "gate": "hitrate_10d_0.50",
+    "start": "2026-01-04",
+    "end": "2026-08-19",
+    "trade_dates": 157,
+    "gate_open": 109,
+    "gate_closed": 48,
+    "trip_rate": 0.3057,
+    "base_ann": 0.255023,
+    "base_sharpe": 1.4465,
+    "base_maxDD": -0.080671,
+    "gated_ann": 0.335822,
+    "gated_sharpe": 2.6391,
+    "gated_maxDD": -0.060142
+  },
+  {
+    "window": "2026",
+    "gate": "hitrate_10d_0.60",
+    "start": "2026-01-04",
+    "end": "2026-08-19",
+    "trade_dates": 157,
+    "gate_open": 36,
+    "gate_closed": 121,
+    "trip_rate": 0.7707,
+    "base_ann": 0.255023,
+    "base_sharpe": 1.4465,
+    "base_maxDD": -0.080671,
+    "gated_ann": 0.251108,
+    "gated_sharpe": 3.8579,
+    "gated_maxDD": -0.026842
+  },
+  {
+    "window": "2026",
+    "gate": "hitrate_10d_0.70",
+    "start": "2026-01-04",
+    "end": "2026-08-19",
+    "trade_dates": 157,
+    "gate_open": 9,
+    "gate_closed": 148,
+    "trip_rate": 0.9427,
+    "base_ann": 0.255023,
+    "base_sharpe": 1.4465,
+    "base_maxDD": -0.080671,
+    "gated_ann": 0.039314,
+    "gated_sharpe": 1.3415,
+    "gated_maxDD": -0.012061
+  },
+  {
+    "window": "2026",
+    "gate": "hitrate_20d_0.40",
+    "start": "2026-01-04",
+    "end": "2026-08-19",
+    "trade_dates": 157,
+    "gate_open": 157,
+    "gate_closed": 0,
+    "trip_rate": 0.0,
+    "base_ann": 0.255023,
+    "base_sharpe": 1.4465,
+    "base_maxDD": -0.080671,
+    "gated_ann": 0.255023,
+    "gated_sharpe": 1.4465,
+    "gated_maxDD": -0.080671
+  },
+  {
+    "window": "2026",
+    "gate": "hitrate_20d_0.50",
+    "start": "2026-01-04",
+    "end": "2026-08-19",
+    "trade_dates": 157,
+    "gate_open": 118,
+    "gate_closed": 39,
+    "trip_rate": 0.2484,
+    "base_ann": 0.255023,
+    "base_sharpe": 1.4465,
+    "base_maxDD": -0.080671,
+    "gated_ann": 0.343819,
+    "gated_sharpe": 2.5185,
+    "gated_maxDD": -0.06259
+  },
+  {
+    "window": "2026",
+    "gate": "hitrate_20d_0.60",
+    "start": "2026-01-04",
+    "end": "2026-08-19",
+    "trade_dates": 157,
+    "gate_open": 28,
+    "gate_closed": 129,
+    "trip_rate": 0.8217,
+    "base_ann": 0.255023,
+    "base_sharpe": 1.4465,
+    "base_maxDD": -0.080671,
+    "gated_ann": 0.020214,
+    "gated_sharpe": 0.3601,
+    "gated_maxDD": -0.028489
+  },
+  {
+    "window": "2025",
+    "gate": "hitrate_5d_0.50",
+    "start": "2025-01-02",
+    "end": "2025-12-31",
+    "trade_dates": 250,
+    "gate_open": 153,
+    "gate_closed": 97,
+    "trip_rate": 0.388,
+    "base_ann": 0.177515,
+    "base_sharpe": 0.8573,
+    "base_maxDD": -0.217417,
+    "gated_ann": 0.72055,
+    "gated_sharpe": 6.9599,
+    "gated_maxDD": -0.048495
+  },
+  {
+    "window": "2025",
+    "gate": "hitrate_5d_0.60",
+    "start": "2025-01-02",
+    "end": "2025-12-31",
+    "trade_dates": 250,
+    "gate_open": 90,
+    "gate_closed": 160,
+    "trip_rate": 0.64,
+    "base_ann": 0.177515,
+    "base_sharpe": 0.8573,
+    "base_maxDD": -0.217417,
+    "gated_ann": 0.48564,
+    "gated_sharpe": 5.3623,
+    "gated_maxDD": -0.046673
+  },
+  {
+    "window": "2025",
+    "gate": "hitrate_5d_0.70",
+    "start": "2025-01-02",
+    "end": "2025-12-31",
+    "trade_dates": 250,
+    "gate_open": 39,
+    "gate_closed": 211,
+    "trip_rate": 0.844,
+    "base_ann": 0.177515,
+    "base_sharpe": 0.8573,
+    "base_maxDD": -0.217417,
+    "gated_ann": 0.249221,
+    "gated_sharpe": 4.9448,
+    "gated_maxDD": -0.009619
+  },
+  {
+    "window": "2025",
+    "gate": "hitrate_10d_0.50",
+    "start": "2025-01-02",
+    "end": "2025-12-31",
+    "trade_dates": 250,
+    "gate_open": 170,
+    "gate_closed": 80,
+    "trip_rate": 0.32,
+    "base_ann": 0.177515,
+    "base_sharpe": 0.8573,
+    "base_maxDD": -0.217417,
+    "gated_ann": 0.435847,
+    "gated_sharpe": 3.5614,
+    "gated_maxDD": -0.055776
+  },
+  {
+    "window": "2025",
+    "gate": "hitrate_10d_0.60",
+    "start": "2025-01-02",
+    "end": "2025-12-31",
+    "trade_dates": 250,
+    "gate_open": 66,
+    "gate_closed": 184,
+    "trip_rate": 0.736,
+    "base_ann": 0.177515,
+    "base_sharpe": 0.8573,
+    "base_maxDD": -0.217417,
+    "gated_ann": 0.324574,
+    "gated_sharpe": 5.2279,
+    "gated_maxDD": -0.016028
+  },
+  {
+    "window": "2025",
+    "gate": "hitrate_10d_0.70",
+    "start": "2025-01-02",
+    "end": "2025-12-31",
+    "trade_dates": 250,
+    "gate_open": 14,
+    "gate_closed": 236,
+    "trip_rate": 0.944,
+    "base_ann": 0.177515,
+    "base_sharpe": 0.8573,
+    "base_maxDD": -0.217417,
+    "gated_ann": 0.043002,
+    "gated_sharpe": 1.4635,
+    "gated_maxDD": -0.010154
+  },
+  {
+    "window": "2025",
+    "gate": "hitrate_20d_0.40",
+    "start": "2025-01-02",
+    "end": "2025-12-31",
+    "trade_dates": 250,
+    "gate_open": 247,
+    "gate_closed": 3,
+    "trip_rate": 0.012,
+    "base_ann": 0.177515,
+    "base_sharpe": 0.8573,
+    "base_maxDD": -0.217417,
+    "gated_ann": 0.202949,
+    "gated_sharpe": 0.9896,
+    "gated_maxDD": -0.217417
+  },
+  {
+    "window": "2025",
+    "gate": "hitrate_20d_0.50",
+    "start": "2025-01-02",
+    "end": "2025-12-31",
+    "trade_dates": 250,
+    "gate_open": 177,
+    "gate_closed": 73,
+    "trip_rate": 0.292,
+    "base_ann": 0.177515,
+    "base_sharpe": 0.8573,
+    "base_maxDD": -0.217417,
+    "gated_ann": 0.340772,
+    "gated_sharpe": 2.8303,
+    "gated_maxDD": -0.071731
+  },
+  {
+    "window": "2025",
+    "gate": "hitrate_20d_0.60",
+    "start": "2025-01-02",
+    "end": "2025-12-31",
+    "trade_dates": 250,
+    "gate_open": 48,
+    "gate_closed": 202,
+    "trip_rate": 0.808,
+    "base_ann": 0.177515,
+    "base_sharpe": 0.8573,
+    "base_maxDD": -0.217417,
+    "gated_ann": 0.266028,
+    "gated_sharpe": 4.1749,
+    "gated_maxDD": -0.021527
+  },
+  {
+    "window": "2024",
+    "gate": "hitrate_5d_0.50",
+    "start": "2024-01-02",
+    "end": "2024-12-31",
+    "trade_dates": 253,
+    "gate_open": 139,
+    "gate_closed": 114,
+    "trip_rate": 0.4506,
+    "base_ann": 0.08229,
+    "base_sharpe": 0.5594,
+    "base_maxDD": -0.10685,
+    "gated_ann": 0.30351,
+    "gated_sharpe": 2.4275,
+    "gated_maxDD": -0.088219
+  },
+  {
+    "window": "2024",
+    "gate": "hitrate_5d_0.60",
+    "start": "2024-01-02",
+    "end": "2024-12-31",
+    "trade_dates": 253,
+    "gate_open": 71,
+    "gate_closed": 182,
+    "trip_rate": 0.7194,
+    "base_ann": 0.08229,
+    "base_sharpe": 0.5594,
+    "base_maxDD": -0.10685,
+    "gated_ann": 0.265365,
+    "gated_sharpe": 2.4908,
+    "gated_maxDD": -0.078304
+  },
+  {
+    "window": "2024",
+    "gate": "hitrate_5d_0.70",
+    "start": "2024-01-02",
+    "end": "2024-12-31",
+    "trade_dates": 253,
+    "gate_open": 19,
+    "gate_closed": 234,
+    "trip_rate": 0.9249,
+    "base_ann": 0.08229,
+    "base_sharpe": 0.5594,
+    "base_maxDD": -0.10685,
+    "gated_ann": 0.143125,
+    "gated_sharpe": 3.377,
+    "gated_maxDD": -0.003364
+  },
+  {
+    "window": "2024",
+    "gate": "hitrate_10d_0.50",
+    "start": "2024-01-02",
+    "end": "2024-12-31",
+    "trade_dates": 253,
+    "gate_open": 157,
+    "gate_closed": 96,
+    "trip_rate": 0.3794,
+    "base_ann": 0.08229,
+    "base_sharpe": 0.5594,
+    "base_maxDD": -0.10685,
+    "gated_ann": 0.277421,
+    "gated_sharpe": 2.5767,
+    "gated_maxDD": -0.043146
+  },
+  {
+    "window": "2024",
+    "gate": "hitrate_10d_0.60",
+    "start": "2024-01-02",
+    "end": "2024-12-31",
+    "trade_dates": 253,
+    "gate_open": 37,
+    "gate_closed": 216,
+    "trip_rate": 0.8538,
+    "base_ann": 0.08229,
+    "base_sharpe": 0.5594,
+    "base_maxDD": -0.10685,
+    "gated_ann": 0.207161,
+    "gated_sharpe": 3.6083,
+    "gated_maxDD": -0.011122
+  },
+  {
+    "window": "2024",
+    "gate": "hitrate_10d_0.70",
+    "start": "2024-01-02",
+    "end": "2024-12-31",
+    "trade_dates": 253,
+    "gate_open": 7,
+    "gate_closed": 246,
+    "trip_rate": 0.9723,
+    "base_ann": 0.08229,
+    "base_sharpe": 0.5594,
+    "base_maxDD": -0.10685,
+    "gated_ann": 0.031785,
+    "gated_sharpe": 1.7408,
+    "gated_maxDD": -0.002083
+  },
+  {
+    "window": "2024",
+    "gate": "hitrate_20d_0.40",
+    "start": "2024-01-02",
+    "end": "2024-12-31",
+    "trade_dates": 253,
+    "gate_open": 247,
+    "gate_closed": 6,
+    "trip_rate": 0.0237,
+    "base_ann": 0.08229,
+    "base_sharpe": 0.5594,
+    "base_maxDD": -0.10685,
+    "gated_ann": 0.078007,
+    "gated_sharpe": 0.5342,
+    "gated_maxDD": -0.10685
+  },
+  {
+    "window": "2024",
+    "gate": "hitrate_20d_0.50",
+    "start": "2024-01-02",
+    "end": "2024-12-31",
+    "trade_dates": 253,
+    "gate_open": 177,
+    "gate_closed": 76,
+    "trip_rate": 0.3004,
+    "base_ann": 0.08229,
+    "base_sharpe": 0.5594,
+    "base_maxDD": -0.10685,
+    "gated_ann": 0.210672,
+    "gated_sharpe": 1.8469,
+    "gated_maxDD": -0.056207
+  },
+  {
+    "window": "2024",
+    "gate": "hitrate_20d_0.60",
+    "start": "2024-01-02",
+    "end": "2024-12-31",
+    "trade_dates": 253,
+    "gate_open": 13,
+    "gate_closed": 240,
+    "trip_rate": 0.9486,
+    "base_ann": 0.08229,
+    "base_sharpe": 0.5594,
+    "base_maxDD": -0.10685,
+    "gated_ann": 0.005953,
+    "gated_sharpe": 0.3039,
+    "gated_maxDD": -0.014443
+  },
+  {
+    "window": "2023",
+    "gate": "hitrate_5d_0.50",
+    "start": "2023-01-03",
+    "end": "2023-12-29",
+    "trade_dates": 250,
+    "gate_open": 139,
+    "gate_closed": 111,
+    "trip_rate": 0.444,
+    "base_ann": -0.047644,
+    "base_sharpe": -0.2738,
+    "base_maxDD": -0.197856,
+    "gated_ann": 0.546654,
+    "gated_sharpe": 4.2124,
+    "gated_maxDD": -0.035676
+  },
+  {
+    "window": "2023",
+    "gate": "hitrate_5d_0.60",
+    "start": "2023-01-03",
+    "end": "2023-12-29",
+    "trade_dates": 250,
+    "gate_open": 79,
+    "gate_closed": 171,
+    "trip_rate": 0.684,
+    "base_ann": -0.047644,
+    "base_sharpe": -0.2738,
+    "base_maxDD": -0.197856,
+    "gated_ann": 0.556291,
+    "gated_sharpe": 5.1026,
+    "gated_maxDD": -0.025449
+  },
+  {
+    "window": "2023",
+    "gate": "hitrate_5d_0.70",
+    "start": "2023-01-03",
+    "end": "2023-12-29",
+    "trade_dates": 250,
+    "gate_open": 34,
+    "gate_closed": 216,
+    "trip_rate": 0.864,
+    "base_ann": -0.047644,
+    "base_sharpe": -0.2738,
+    "base_maxDD": -0.197856,
+    "gated_ann": 0.404269,
+    "gated_sharpe": 4.4477,
+    "gated_maxDD": -0.013842
+  },
+  {
+    "window": "2023",
+    "gate": "hitrate_10d_0.50",
+    "start": "2023-01-03",
+    "end": "2023-12-29",
+    "trade_dates": 250,
+    "gate_open": 148,
+    "gate_closed": 102,
+    "trip_rate": 0.408,
+    "base_ann": -0.047644,
+    "base_sharpe": -0.2738,
+    "base_maxDD": -0.197856,
+    "gated_ann": 0.459869,
+    "gated_sharpe": 3.5211,
+    "gated_maxDD": -0.046921
+  },
+  {
+    "window": "2023",
+    "gate": "hitrate_10d_0.60",
+    "start": "2023-01-03",
+    "end": "2023-12-29",
+    "trade_dates": 250,
+    "gate_open": 62,
+    "gate_closed": 188,
+    "trip_rate": 0.752,
+    "base_ann": -0.047644,
+    "base_sharpe": -0.2738,
+    "base_maxDD": -0.197856,
+    "gated_ann": 0.368232,
+    "gated_sharpe": 4.0148,
+    "gated_maxDD": -0.022983
+  },
+  {
+    "window": "2023",
+    "gate": "hitrate_10d_0.70",
+    "start": "2023-01-03",
+    "end": "2023-12-29",
+    "trade_dates": 250,
+    "gate_open": 13,
+    "gate_closed": 237,
+    "trip_rate": 0.948,
+    "base_ann": -0.047644,
+    "base_sharpe": -0.2738,
+    "base_maxDD": -0.197856,
+    "gated_ann": 0.091481,
+    "gated_sharpe": 2.1324,
+    "gated_maxDD": -0.010866
+  },
+  {
+    "window": "2023",
+    "gate": "hitrate_20d_0.40",
+    "start": "2023-01-03",
+    "end": "2023-12-29",
+    "trade_dates": 250,
+    "gate_open": 237,
+    "gate_closed": 13,
+    "trip_rate": 0.052,
+    "base_ann": -0.047644,
+    "base_sharpe": -0.2738,
+    "base_maxDD": -0.197856,
+    "gated_ann": 0.06639,
+    "gated_sharpe": 0.3895,
+    "gated_maxDD": -0.146704
+  },
+  {
+    "window": "2023",
+    "gate": "hitrate_20d_0.50",
+    "start": "2023-01-03",
+    "end": "2023-12-29",
+    "trade_dates": 250,
+    "gate_open": 149,
+    "gate_closed": 101,
+    "trip_rate": 0.404,
+    "base_ann": -0.047644,
+    "base_sharpe": -0.2738,
+    "base_maxDD": -0.197856,
+    "gated_ann": 0.366016,
+    "gated_sharpe": 2.5969,
+    "gated_maxDD": -0.063998
+  },
+  {
+    "window": "2023",
+    "gate": "hitrate_20d_0.60",
+    "start": "2023-01-03",
+    "end": "2023-12-29",
+    "trade_dates": 250,
+    "gate_open": 40,
+    "gate_closed": 210,
+    "trip_rate": 0.84,
+    "base_ann": -0.047644,
+    "base_sharpe": -0.2738,
+    "base_maxDD": -0.197856,
+    "gated_ann": 0.149844,
+    "gated_sharpe": 2.2645,
+    "gated_maxDD": -0.032267
+  },
+  {
+    "window": "2021",
+    "gate": "hitrate_5d_0.50",
+    "start": "2021-01-04",
+    "end": "2021-12-31",
+    "trade_dates": 252,
+    "gate_open": 145,
+    "gate_closed": 107,
+    "trip_rate": 0.4246,
+    "base_ann": 0.18367,
+    "base_sharpe": 1.0979,
+    "base_maxDD": -0.102651,
+    "gated_ann": 0.556615,
+    "gated_sharpe": 5.9167,
+    "gated_maxDD": -0.028062
+  },
+  {
+    "window": "2021",
+    "gate": "hitrate_5d_0.60",
+    "start": "2021-01-04",
+    "end": "2021-12-31",
+    "trade_dates": 252,
+    "gate_open": 68,
+    "gate_closed": 184,
+    "trip_rate": 0.7302,
+    "base_ann": 0.18367,
+    "base_sharpe": 1.0979,
+    "base_maxDD": -0.102651,
+    "gated_ann": 0.351867,
+    "gated_sharpe": 5.8468,
+    "gated_maxDD": -0.011638
+  },
+  {
+    "window": "2021",
+    "gate": "hitrate_5d_0.70",
+    "start": "2021-01-04",
+    "end": "2021-12-31",
+    "trade_dates": 252,
+    "gate_open": 26,
+    "gate_closed": 226,
+    "trip_rate": 0.8968,
+    "base_ann": 0.18367,
+    "base_sharpe": 1.0979,
+    "base_maxDD": -0.102651,
+    "gated_ann": 0.148417,
+    "gated_sharpe": 3.9593,
+    "gated_maxDD": -0.0041
+  },
+  {
+    "window": "2021",
+    "gate": "hitrate_10d_0.50",
+    "start": "2021-01-04",
+    "end": "2021-12-31",
+    "trade_dates": 252,
+    "gate_open": 163,
+    "gate_closed": 89,
+    "trip_rate": 0.3532,
+    "base_ann": 0.18367,
+    "base_sharpe": 1.0979,
+    "base_maxDD": -0.102651,
+    "gated_ann": 0.465023,
+    "gated_sharpe": 4.2342,
+    "gated_maxDD": -0.040569
+  },
+  {
+    "window": "2021",
+    "gate": "hitrate_10d_0.60",
+    "start": "2021-01-04",
+    "end": "2021-12-31",
+    "trade_dates": 252,
+    "gate_open": 51,
+    "gate_closed": 201,
+    "trip_rate": 0.7976,
+    "base_ann": 0.18367,
+    "base_sharpe": 1.0979,
+    "base_maxDD": -0.102651,
+    "gated_ann": 0.21802,
+    "gated_sharpe": 4.7978,
+    "gated_maxDD": -0.011134
+  },
+  {
+    "window": "2021",
+    "gate": "hitrate_10d_0.70",
+    "start": "2021-01-04",
+    "end": "2021-12-31",
+    "trade_dates": 252,
+    "gate_open": 13,
+    "gate_closed": 239,
+    "trip_rate": 0.9484,
+    "base_ann": 0.18367,
+    "base_sharpe": 1.0979,
+    "base_maxDD": -0.102651,
+    "gated_ann": 0.06108,
+    "gated_sharpe": 2.7055,
+    "gated_maxDD": -0.000262
+  },
+  {
+    "window": "2021",
+    "gate": "hitrate_20d_0.40",
+    "start": "2021-01-04",
+    "end": "2021-12-31",
+    "trade_dates": 252,
+    "gate_open": 252,
+    "gate_closed": 0,
+    "trip_rate": 0.0,
+    "base_ann": 0.18367,
+    "base_sharpe": 1.0979,
+    "base_maxDD": -0.102651,
+    "gated_ann": 0.18367,
+    "gated_sharpe": 1.0979,
+    "gated_maxDD": -0.102651
+  },
+  {
+    "window": "2021",
+    "gate": "hitrate_20d_0.50",
+    "start": "2021-01-04",
+    "end": "2021-12-31",
+    "trade_dates": 252,
+    "gate_open": 166,
+    "gate_closed": 86,
+    "trip_rate": 0.3413,
+    "base_ann": 0.18367,
+    "base_sharpe": 1.0979,
+    "base_maxDD": -0.102651,
+    "gated_ann": 0.289756,
+    "gated_sharpe": 2.5787,
+    "gated_maxDD": -0.049244
+  },
+  {
+    "window": "2021",
+    "gate": "hitrate_20d_0.60",
+    "start": "2021-01-04",
+    "end": "2021-12-31",
+    "trade_dates": 252,
+    "gate_open": 38,
+    "gate_closed": 214,
+    "trip_rate": 0.8492,
+    "base_ann": 0.18367,
+    "base_sharpe": 1.0979,
+    "base_maxDD": -0.102651,
+    "gated_ann": 0.104685,
+    "gated_sharpe": 2.394,
+    "gated_maxDD": -0.015084
+  }
+]

book/scripts/signal_quality_gate_bt.py

@@ -0,0 +1,293 @@
+"""Signal-quality gate walk-forward backtest.
+
+Gates trades based on whether the model's recent topk predictions were correct
+(hit rate). This is a retrospective gate — it measures prediction accuracy,
+not market state.
+
+Usage:
+    cd /app && .venv/bin/python book/scripts/signal_quality_gate_bt.py
+"""
+
+from __future__ import annotations
+
+import json
+import pathlib
+import sys
+import time
+
+import numpy as np
+import pandas as pd
+
+LAKE_ROOT = "/home/data/lake"
+MARKET = "US"
+OUT_DIR = pathlib.Path("/app/experiments/book/data/signal_quality_gate")
+
+WINDOWS = [
+    {"label": "2026", "start": "2026-01-04", "end": "2026-08-19",
+     "pred": f"{LAKE_ROOT}/mlruns/52/9f98ea5c550a409f87b56a6cd8fee343/artifacts/pred.pkl"},
+    {"label": "2025", "start": "2025-01-02", "end": "2025-12-31",
+     "pred": f"{LAKE_ROOT}/mlruns/52/fe96741654df4780957a3a949999ae6a/artifacts/pred.pkl"},
+    {"label": "2024", "start": "2024-01-02", "end": "2024-12-31",
+     "pred": f"{LAKE_ROOT}/mlruns/52/71ed5bfa9984490f8bba8b222f7acc39/artifacts/pred.pkl"},
+    {"label": "2023", "start": "2023-01-03", "end": "2023-12-29",
+     "pred": f"{LAKE_ROOT}/mlruns/56/8ca46e554311444c9a42637a788226e8/artifacts/pred.pkl"},
+    {"label": "2021", "start": "2021-01-04", "end": "2021-12-31",
+     "pred": f"{LAKE_ROOT}/mlruns/56/4e0700ddab2a4e108b46efece7346ee3/artifacts/pred.pkl"},
+]
+
+# Signal-quality gate configs: (lookback_days, threshold, name)
+SIGNAL_GATE_CONFIGS = [
+    (5, 0.50, "hitrate_5d_0.50"),
+    (5, 0.60, "hitrate_5d_0.60"),
+    (5, 0.70, "hitrate_5d_0.70"),
+    (10, 0.50, "hitrate_10d_0.50"),
+    (10, 0.60, "hitrate_10d_0.60"),
+    (10, 0.70, "hitrate_10d_0.70"),
+    (20, 0.40, "hitrate_20d_0.40"),
+    (20, 0.50, "hitrate_20d_0.50"),
+    (20, 0.60, "hitrate_20d_0.60"),
+]
+
+
+def load_pred(path: str) -> pd.Series:
+    df = pd.read_pickle(path)
+    if isinstance(df, pd.DataFrame):
+        if "score" in df.columns:
+            s = df["score"]
+        else:
+            s = df.iloc[:, 0]
+    else:
+        s = df
+    idx = s.index
+    new_dt = pd.to_datetime(idx.get_level_values(0)).normalize()
+    s.index = pd.MultiIndex.from_arrays([new_dt, idx.get_level_values(1)], names=idx.names)
+    return s
+
+
+def load_bars_for_window(start: str, end: str) -> pd.DataFrame:
+    from tac_qlib.data.config import LakeConfig, resolve_lake_root
+    cfg = LakeConfig(resolve_lake_root(LAKE_ROOT), MARKET)
+    sp = cfg.lake_root / "symbols.parquet"
+    if sp.exists():
+        syms = pd.read_parquet(sp)
+        col = "symbol" if "symbol" in syms.columns else syms.columns[0]
+        symbols = sorted(syms[col].astype(str).str.upper().tolist())
+    else:
+        return pd.DataFrame()
+    closes = {}
+    for sym in symbols:
+        p = cfg.bar_path("1d", sym)
+        if not p.exists():
+            continue
+        try:
+            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()
+        warmup_start = pd.Timestamp(start) - pd.Timedelta(days=60)
+        df = df.loc[warmup_start:end]
+        if len(df) >= 22:
+            closes[sym] = df["c"]
+    return pd.DataFrame(closes)
+
+
+def compute_hit_rate_series(
+    pred: pd.Series, ret_df: pd.DataFrame, topk: int = 10, lookback: int = 10,
+) -> pd.Series:
+    dt_idx = pred.index.get_level_values(0)
+    trade_dates = sorted(dt_idx.unique())
+    hit_rates = {}
+    for i in range(1, len(trade_dates)):
+        prev_date = trade_dates[i - 1]
+        curr_date = trade_dates[i]
+        try:
+            prev_scores = pred.loc[prev_date]
+        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])
+        if curr_date not in ret_df.index:
+            continue
+        today_ret = ret_df.loc[curr_date]
+        topk_rets = today_ret.reindex(topk_syms).dropna()
+        if len(topk_rets) > 0:
+            hit_rate = (topk_rets > 0).mean()
+            hit_rates[curr_date] = hit_rate
+    hit_series = pd.Series(hit_rates)
+    if len(hit_series) == 0:
+        return hit_series
+    rolling_hr = hit_series.rolling(lookback, min_periods=max(1, lookback // 2)).mean()
+    return rolling_hr
+
+
+def run_backtest(pred, hit_rate, close_df, start, end, topk=10, threshold=0.5):
+    if not isinstance(pred.index, pd.MultiIndex):
+        return {"error": "pred must have MultiIndex"}
+    ret_df = close_df.pct_change()
+    ret_df.index = pd.to_datetime(ret_df.index).normalize()
+    dt_idx = pred.index.get_level_values(0)
+    window_mask = (dt_idx >= pd.Timestamp(start)) & (dt_idx <= pd.Timestamp(end))
+    window_pred = pred.loc[window_mask]
+    if len(window_pred) == 0:
+        return {"error": "no pred data in window"}
+    trade_dates = sorted(dt_idx[window_mask].unique())
+    gate_open = {}
+    for d in trade_dates:
+        known = hit_rate[hit_rate.index <= d]
+        if len(known) > 0 and not pd.isna(known.iloc[-1]):
+            gate_open[d] = bool(known.iloc[-1] >= threshold)
+        else:
+            gate_open[d] = True
+    n_total = len(trade_dates)
+    n_open = sum(1 for v in gate_open.values() if v)
+    n_closed = n_total - n_open
+    holdings_base = []
+    holdings_gated = []
+    equity_gated = 1_000_000.0
+    equity_base = 1_000_000.0
+    prev_week = None
+    prev_scores = None
+    daily_gated = []
+    daily_base = []
+    ret_by_date = {rd: ret_df.loc[rd] for rd in ret_df.index}
+    for d in trade_dates:
+        try:
+            day_scores = window_pred.loc[d]
+        except KeyError:
+            daily_gated.append(equity_gated)
+            daily_base.append(equity_base)
+            prev_scores = None
+            continue
+        if isinstance(day_scores, pd.DataFrame):
+            day_scores = day_scores.iloc[:, 0]
+        day_scores = day_scores.dropna().sort_values(ascending=False)
+        if len(day_scores) == 0:
+            daily_gated.append(equity_gated)
+            daily_base.append(equity_base)
+            prev_scores = None
+            continue
+        ret_row = ret_by_date.get(d)
+        if ret_row is None:
+            daily_gated.append(equity_gated)
+            daily_base.append(equity_base)
+            prev_scores = day_scores
+            continue
+        cur_week = (d.isocalendar()[0], d.isocalendar()[1]) if hasattr(d, 'isocalendar') else None
+        gate_val = gate_open.get(d, True)
+        if cur_week != prev_week or not holdings_base:
+            if prev_scores is not None:
+                holdings_base = list(prev_scores.index[:topk])
+        if holdings_base:
+            base_rets = ret_row.reindex(holdings_base).dropna()
+            if len(base_rets) > 0:
+                equity_base *= (1 + base_rets.mean())
+        if gate_val:
+            if cur_week != prev_week or not holdings_gated:
+                if prev_scores is not None:
+                    holdings_gated = list(prev_scores.index[:topk])
+            if holdings_gated:
+                hold_rets = ret_row.reindex(holdings_gated).dropna()
+                if len(hold_rets) > 0:
+                    equity_gated *= (1 + hold_rets.mean())
+        else:
+            holdings_gated = []
+        prev_week = cur_week
+        prev_scores = day_scores
+        daily_gated.append(equity_gated)
+        daily_base.append(equity_base)
+    g_series = pd.Series(daily_gated, index=trade_dates)
+    b_series = pd.Series(daily_base, index=trade_dates)
+    def _metrics(eq):
+        if len(eq) < 2:
+            return {"ann_return": 0, "sharpe": 0, "maxDD": 0}
+        rets = eq.pct_change().dropna()
+        ann_ret = float((eq.iloc[-1] / eq.iloc[0]) ** (252 / max(len(eq), 1)) - 1)
+        vol = float(rets.std() * (252 ** 0.5)) if len(rets) > 1 else 0
+        sharpe = ann_ret / vol if vol > 0 else 0
+        peak = eq.cummax()
+        dd = (eq - peak) / peak
+        maxDD = float(dd.min())
+        return {"ann_return": round(ann_ret, 6), "sharpe": round(sharpe, 4), "maxDD": round(maxDD, 6)}
+    base_m = _metrics(b_series)
+    gated_m = _metrics(g_series)
+    return {
+        "trade_dates": n_total,
+        "gate_open_days": n_open,
+        "gate_closed_days": n_closed,
+        "trip_rate": round(n_closed / n_total, 4) if n_total else 0,
+        "base": base_m,
+        "gated": gated_m,
+    }
+
+
+def main():
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+    full_start = "2015-01-03"
+    full_end = "2026-08-19"
+    print("Loading lake bars...")
+    close_df = load_bars_for_window(full_start, full_end)
+    print(f"  {close_df.shape[1]} symbols, {close_df.shape[0]} days")
+    ret_df = close_df.pct_change()
+    ret_df.index = pd.to_datetime(ret_df.index).normalize()
+    results = []
+    for window in WINDOWS:
+        wl, ws, we = window["label"], window["start"], window["end"]
+        pred_path = window["pred"]
+        print(f"\n=== Window {wl} ({ws} to {we}) ===")
+        pred = load_pred(pred_path)
+        print(f"  pred shape: {pred.shape}")
+        hit_rates = {}
+        for lookback, _, name in SIGNAL_GATE_CONFIGS:
+            if lookback not in hit_rates:
+                hr = compute_hit_rate_series(pred, ret_df, topk=10, lookback=lookback)
+                hit_rates[lookback] = hr
+                print(f"  lookback={lookback}: {len(hr)} days with hit rates")
+        for lookback, threshold, name in SIGNAL_GATE_CONFIGS:
+            hr = hit_rates[lookback]
+            bt = run_backtest(pred, hr, close_df, ws, we, topk=10, threshold=threshold)
+            if "error" in bt:
+                print(f"  {name}: {bt['error']}")
+                continue
+            row = {
+                "window": wl,
+                "gate": name,
+                "start": ws,
+                "end": we,
+                "trade_dates": bt["trade_dates"],
+                "gate_open": bt["gate_open_days"],
+                "gate_closed": bt["gate_closed_days"],
+                "trip_rate": bt["trip_rate"],
+                "base_ann": bt["base"]["ann_return"],
+                "base_sharpe": bt["base"]["sharpe"],
+                "base_maxDD": bt["base"]["maxDD"],
+                "gated_ann": bt["gated"]["ann_return"],
+                "gated_sharpe": bt["gated"]["sharpe"],
+                "gated_maxDD": bt["gated"]["maxDD"],
+            }
+            results.append(row)
+            print(f"  {name}: trip={bt['trip_rate']:.1%}, "
+                  f"base={bt['base']['ann_return']:+.1%} (Sharpe {bt['base']['sharpe']:.2f}), "
+                  f"gated={bt['gated']['ann_return']:+.1%} (Sharpe {bt['gated']['sharpe']:.2f})")
+    df = pd.DataFrame(results)
+    out_path = OUT_DIR / "signal_quality_gate_results.csv"
+    df.to_csv(out_path, index=False)
+    with open(OUT_DIR / "signal_quality_gate_results.json", "w") as f:
+        json.dump(df.to_dict(orient="records"), f, indent=2, default=str)
+    print(f"\nSaved to {out_path}")
+    print("\n=== Summary: Gated Return by Window ===")
+    for gate_name in df["gate"].unique():
+        gdf = df[df["gate"] == gate_name]
+        print(f"\n{gate_name}:")
+        for _, r in gdf.iterrows():
+            print(f"  {r['window']}: base={r['base_ann']:+.1%}, gated={r['gated_ann']:+.1%}, "
+                  f"trip={r['trip_rate']:.0%}, diff={r['gated_ann']-r['base_ann']:+.1%}pp")
+
+
+if __name__ == "__main__":
+    main()

code/MANIFEST.txt

@@ -1,25 +1,30 @@
 # TradeAC custom-qlib-code snapshot (auto-generated)
-# parent repo HEAD : fd5382caa4c4e96417a16d5a22006d9a7d625d00
+# parent repo HEAD : ceb1e196e24761a87d1afe1bde00079b79e02693
 #   tac-qlib/tac_qlib/contrib
 #   tac-qlib/tac_qlib/data
 # per-file hashes (git hash-object):
   1b6298c4a5652f2e863cbdc385a1014a570fcd59  tac-qlib/tac_qlib/contrib/__init__.py
-  2224424d0ff193be4f55d1b791f8fce89439c5d2  tac-qlib/tac_qlib/contrib/backtest/__init__.py
+  861592c63edd6a0853a9cb174b5970435b135fc8  tac-qlib/tac_qlib/contrib/__pycache__/__init__.cpython-312.pyc
-  0bf40dee440ddbded357d7bbb4efc67c62c4b084  tac-qlib/tac_qlib/contrib/backtest/tradeac_exchange.py
   c76a9f17f680e74eea766eff27f7624359749ed6  tac-qlib/tac_qlib/contrib/data/__init__.py
-  3bba0f1696e4ab4b3deebec3f31f269b2e713899  tac-qlib/tac_qlib/contrib/data/handler.py
+  5c547a2ef92e075e550fe6d01508a2f1d3f536bc  tac-qlib/tac_qlib/contrib/data/__pycache__/__init__.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
+  b1489f2fc0dee85f0a4f90b2e6ad545ed9c8967b  tac-qlib/tac_qlib/contrib/model/__pycache__/__init__.cpython-312.pyc
+  121ef237da1df1b8e21a561c3ad0db200b901339  tac-qlib/tac_qlib/contrib/model/__pycache__/rank_ensemble.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
-  184f80da8edf944bad3c8fb4d4d3d189bf4f082b  tac-qlib/tac_qlib/contrib/strategy/__init__.py
+  2c2f167b693f4366a769998e3c9d4804f29e31e0  tac-qlib/tac_qlib/contrib/strategy/__init__.py
-  896ef74ae47bcd1ed388e1e5d9c8d70c28097fe9  tac-qlib/tac_qlib/contrib/strategy/kelly_dropout.py
+  c29e45e562256bf786c36f91a971b097467276e9  tac-qlib/tac_qlib/contrib/strategy/__pycache__/__init__.cpython-312.pyc
-  9090fc6dfbd339f2f4df4b0c9b87f400ecb5c9d5  tac-qlib/tac_qlib/contrib/strategy/long_short.py
+  6dd1c568a2961842793674390d5abffd1a0e71b8  tac-qlib/tac_qlib/contrib/strategy/__pycache__/optimal_stop.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
-  839abb89ad40cd516eabcfd91fe1be626b9f091f  tac-qlib/tac_qlib/contrib/strategy/weekly_rebalance.py
+  fe60bacdfedd48617863be31f24b7c7daebfac5a  tac-qlib/tac_qlib/contrib/strategy/weekly_rebalance.py
   92e6e90eb0cd0a25142034560f27adb6b705b1a8  tac-qlib/tac_qlib/data/__init__.py
-  888c039f251cdf76c793ce7ba78ff60806afd069  tac-qlib/tac_qlib/data/__pycache__/__init__.cpython-312.pyc
+  316bf4aa160cc8d15929ea648be03f4b4999667d  tac-qlib/tac_qlib/data/__pycache__/__init__.cpython-312.pyc
-  26f27f9607d1a4bff09776fc58ff1c9614480d01  tac-qlib/tac_qlib/data/__pycache__/config.cpython-312.pyc
+  554a3f29d181b64effbf49a8161b32e7f93d8d3e  tac-qlib/tac_qlib/data/__pycache__/config.cpython-312.pyc
-  ada62e1628f7c615cc904f9a96f91c85677e16ed  tac-qlib/tac_qlib/data/__pycache__/providers.cpython-312.pyc
+  8b47f6d78ac046b6b7b2fb07bd7f3382773ffb73  tac-qlib/tac_qlib/data/__pycache__/providers.cpython-312.pyc
-  1953fb2a6371525db7f7b0e1c9dfbf3492d82110  tac-qlib/tac_qlib/data/config.py
+  53c9007a928841fd3c3b08450f9a6520ce1ac091  tac-qlib/tac_qlib/data/config.py
   8d0644f6f0d1efb94798ed444cc73e63b643459b  tac-qlib/tac_qlib/data/providers.py

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

@@ -1 +0,0 @@
-from .tradeac_exchange import TradeACExchange

code/tac-qlib/tac_qlib/contrib/backtest/tradeac_exchange.py

@@ -1,432 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-"""
-TradeACExchange
-
-A short/borrow enabled Exchange implementation built on top of qlib.backtest.exchange.Exchange.
-This exchange adds simple, configurable margin logic (initial/maintenance), borrowing support for
-shorts, a borrow fee, and a lightweight SMA (Special Memorandum Account) concept to emulate
-behaviors similar to brokers such as IBKR and Alpaca for backtesting purposes.
-
-Notes / limitations
-- This implementation is intentionally lightweight and conservative: it implements the
-  key behaviors needed for strategy/backtest experiments (allowing short selling, computing
-  margin requirements, performing margin-call checks, and tracking SMA-like excess equity).
-- It makes some simplifying assumptions compared to real brokers (no per-product house margins,
-  simplified SMA bookkeeping, borrow availability modeled only by a per-symbol boolean/limit).
-- The Position class in qlib.backtest.position was not changed. To support shorts we update the
-  position.position dict directly when necessary. This keeps integration simple but bypasses some
-  internal Position helpers. Use with care.
-
-API additions
-- allow_short: enable short selling (bool)
-- initial_margin_long/short: fraction required to open a position
-- maintenance_margin_long/short: fraction required to keep a position
-- borrow_fee_rate: periodic borrow fee applied on short value (applied at trade time as additional cost)
-- borrowable: dict mapping stock_id -> bool or float (max borrowable shares). Symbols missing from
-  the dict follow `borrow_default` (default True = unlimited; set False for a strict whitelist)
-- get_sma(position): returns SMA-like excess equity available as "buying power credit"
-- check_margin_call(position): returns True if position is below maintenance requirement
-
-"""
-from __future__ import annotations
-
-from typing import Any, Dict, Optional, Tuple
-
-import numpy as np
-
-from qlib.backtest.decision import Order
-from qlib.backtest.exchange import Exchange
-from qlib.backtest.position import BasePosition
-
-
-class TradeACExchange(Exchange):
-    """An exchange that supports short selling / borrowing and basic margin rules.
-
-    The implementation aims to be compatible with the Exchange API used by Account and
-    Position classes in qlib.backtest. It overrides only the minimum methods required to
-    enable short/borrow behavior and margin calculations.
-    """
-
-    def __init__(
-        self,
-        *args: Any,
-        allow_short: bool = True,
-        initial_margin_long: float = 0.5,
-        initial_margin_short: float = 0.5,
-        maintenance_margin_long: float = 0.25,
-        maintenance_margin_short: float = 0.3,
-        borrow_fee_rate: float = 0.0,
-        borrowable: Optional[Dict[str, float]] = None,
-        borrow_default: bool = True,
-        sma_enabled: bool = True,
-        **kwargs: Any,
-    ) -> None:
-        """Create TradeACExchange.
-
-        Parameters mirror Exchange with additional tradeac-specific options.
-        """
-        super().__init__(*args, **kwargs)
-        self.allow_short = allow_short
-        self.initial_margin_long = initial_margin_long
-        self.initial_margin_short = initial_margin_short
-        self.maintenance_margin_long = maintenance_margin_long
-        self.maintenance_margin_short = maintenance_margin_short
-        self.borrow_fee_rate = borrow_fee_rate
-        # borrowable can be a dict with per-symbol max borrowable amount, or None (unlimited)
-        self.borrowable = borrowable or {}
-        # borrow_default: policy for symbols absent from `borrowable`.
-        #   True  -> unlisted symbols are unlimited-borrowable (legacy behavior)
-        #   False -> unlisted symbols are NOT borrowable; only listed ones can be shorted
-        self.borrow_default = bool(borrow_default)
-        # sma_enabled: whether to expose lightweight SMA calculation
-        self.sma_enabled = sma_enabled
-
-    # --------------------------- Helper calculations ---------------------------
-    def _initial_margin_requirement(self, position: BasePosition) -> float:
-        """Compute the initial margin requirement (money) for the given position.
-
-        We treat longs and shorts separately and sum their required initial margins.
-        """
-        im_req = 0.0
-        for sid in position.get_stock_list():
-            amt = position.get_stock_amount(sid)
-            price = position.get_stock_price(sid)
-            val = amt * price
-            if val > 0:
-                im_req += abs(val) * self.initial_margin_long
-            elif val < 0:
-                im_req += abs(val) * self.initial_margin_short
-        return im_req
-
-    def _maintenance_margin_requirement(self, position: BasePosition) -> float:
-        """Compute the maintenance margin requirement (money) for the given position."""
-        mm_req = 0.0
-        for sid in position.get_stock_list():
-            amt = position.get_stock_amount(sid)
-            price = position.get_stock_price(sid)
-            val = amt * price
-            if val > 0:
-                mm_req += abs(val) * self.maintenance_margin_long
-            elif val < 0:
-                mm_req += abs(val) * self.maintenance_margin_short
-        return mm_req
-
-    def get_equity(self, position: BasePosition) -> float:
-        """Return account equity (position value + cash)."""
-        return position.calculate_value()
-
-    def get_sma(self, position: BasePosition) -> float:
-        """Return a simplified SMA: excess equity above initial margin requirement.
-
-        Note: This is a synthetic/Simplified SMA used for strategy/backtest logic. Real-broker
-        SMA accounting (e.g. credits/debits across days) can be more complex.
-        """
-        if not self.sma_enabled:
-            return 0.0
-        equity = self.get_equity(position)
-        im_req = self._initial_margin_requirement(position)
-        return max(0.0, equity - im_req)
-
-    def check_margin_call(self, position: BasePosition) -> bool:
-        """Return True when the account is under maintenance margin (margin call).
-
-        Margin call condition here is simple: equity < maintenance requirement.
-        """
-        equity = self.get_equity(position)
-        mm_req = self._maintenance_margin_requirement(position)
-        return equity < mm_req
-
-    def get_buying_power(self, position: BasePosition) -> float:
-        """Estimate buying power for new long positions assuming opening margin requirement.
-
-        Simplified: the maximum notional long value = equity / initial_margin_long.
-        """
-        equity = self.get_equity(position)
-        if self.initial_margin_long <= 0:
-            return 0.0
-        return equity / self.initial_margin_long
-
-    # --------------------------- Order / execution overrides ---------------------------
-    def _borrow_headroom(self, stock_id: str, current_short: float) -> float:
-        """Remaining borrowable shares for `stock_id` given an already-open short of `current_short` shares.
-
-        borrowable values: bool (True=unlimited, False=not borrowable) or numeric max shares.
-        Missing symbols follow `borrow_default` (True = unlimited when allow_short is enabled).
-        """
-        if not self.allow_short:
-            return 0.0
-        v = self.borrowable.get(stock_id, self.borrow_default)
-        if isinstance(v, bool):
-            return float("inf") if v else 0.0
-        try:
-            limit = float(v)
-        except (TypeError, ValueError):
-            return float("inf")
-        return max(0.0, limit - max(current_short, 0.0))
-
-    def _calc_trade_info_by_order(
-        self,
-        order: Order,
-        position: Optional[BasePosition],
-        dealt_order_amount: Dict[str, float],
-    ) -> Tuple[float, float, float]:
-        """Override to allow (optionally) short selling and to apply borrow fees.
-
-        The original Exchange implementation forbids selling more than you own. Here we allow
-        sell orders to create/expand short positions when allow_short is True. We still rely on
-        most base logic (price discovery, impact, cost calculation) by calling super(), but we
-        adjust the sell-side clipping behavior before delegating to the base implementation.
-        """
-        # When selling and shorts are allowed, temporarily relax the clipping logic in the base
-        # implementation by monkey-patching current position check. Simpler: replicate minimal
-        # parts of logic from Exchange._calc_trade_info_by_order with the key change.
-
-        # Get basic trade price & volume info using Exchange helpers
-        trade_price = float(self.get_deal_price(order.stock_id, order.start_time, order.end_time, direction=order.direction))
-        total_trade_val = float(self.get_volume(order.stock_id, order.start_time, order.end_time) or 0.0) * trade_price
-
-        order.factor = self.get_factor(order.stock_id, order.start_time, order.end_time)
-        order.deal_amount = order.amount  # attempt full
-
-        # volume clipping (same as base)
-        self._clip_amount_by_volume(order, dealt_order_amount)
-
-        # approximate adjusted cost ratio based on liquidity
-        if not total_trade_val or np.isnan(total_trade_val) or total_trade_val <= 0:
-            adj_cost_ratio = self.impact_cost
-        else:
-            trade_val_tmp = order.deal_amount * trade_price
-            adj_cost_ratio = self.impact_cost * (trade_val_tmp / total_trade_val) ** 2
-
-        # Differentiate buy / sell
-        if order.direction == Order.SELL:
-            cost_ratio = self.close_cost + adj_cost_ratio
-            current_amount = (
-                position.get_stock_amount(order.stock_id) if (position is not None and position.check_stock(order.stock_id)) else 0.0
-            )
-            long_held = max(current_amount, 0.0)
-            short_open = max(-current_amount, 0.0)
-
-            if position is not None:
-                if not self.allow_short:
-                    # clip by current holdings only
-                    if not np.isclose(order.deal_amount, current_amount):
-                        order.deal_amount = self.round_amount_by_trade_unit(
-                            min(long_held, order.deal_amount), order.factor
-                        )
-                else:
-                    # allow selling beyond holdings up to the remaining borrow limit;
-                    # later when updating the position we create/expand a short if necessary.
-                    max_sell = long_held + self._borrow_headroom(order.stock_id, short_open)
-                    if order.deal_amount > max_sell and not np.isclose(order.deal_amount, max_sell):
-                        order.deal_amount = self.round_amount_by_trade_unit(max_sell, order.factor)
-
-        elif order.direction == Order.BUY:
-            cost_ratio = self.open_cost + adj_cost_ratio
-            if position is not None:
-                cash = position.get_cash()
-                trade_val = order.deal_amount * trade_price
-                if cash < max(trade_val * cost_ratio, self.min_cost):
-                    order.deal_amount = 0
-                    self.logger.debug(f"Order clipped due to cost higher than cash: {order}")
-                elif cash < trade_val + max(trade_val * cost_ratio, self.min_cost):
-                    max_buy_amount = self._get_buy_amount_by_cash_limit(trade_price, cash, cost_ratio)
-                    order.deal_amount = self.round_amount_by_trade_unit(min(max_buy_amount, order.deal_amount), order.factor)
-                    self.logger.debug(f"Order clipped due to cash limitation: {order}")
-                else:
-                    order.deal_amount = self.round_amount_by_trade_unit(order.deal_amount, order.factor)
-            else:
-                order.deal_amount = self.round_amount_by_trade_unit(order.deal_amount, order.factor)
-        else:
-            raise NotImplementedError("order direction {} error".format(order.direction))
-
-        # compute final trade_val & trade_cost
-        trade_val = order.deal_amount * trade_price
-        # base trade_cost
-        trade_cost = max(trade_val * cost_ratio, self.min_cost)
-        # apply borrow fee only on the net-new short portion of the sell
-        if order.direction == Order.SELL and self.allow_short:
-            new_short = max(0.0, order.deal_amount - long_held)
-            trade_cost += new_short * trade_price * self.borrow_fee_rate
-
-        if trade_val <= 1e-5:
-            trade_cost = 0
-
-        return trade_price, trade_val, trade_cost
-
-    def deal_order(
-        self,
-        order: Order,
-        trade_account: Optional[Any] = None,
-        position: Optional[BasePosition] = None,
-        dealt_order_amount: Dict[str, float] = None,
-    ) -> Tuple[float, float, float]:
-        """Deal order and handle short position bookkeeping.
-
-        This method mirrors Exchange.deal_order but when a position is provided and shorts are
-        allowed it will update the Position.position dict directly to support negative amounts.
-        """
-        if dealt_order_amount is None:
-            dealt_order_amount = {}
-
-        if not self.check_order(order):
-            order.deal_amount = 0.0
-            self.logger.debug(f"Order failed due to trading limitation: {order}")
-            return 0.0, 0.0, np.nan
-
-        if trade_account is not None and position is not None:
-            raise ValueError("trade_account and position can only choose one")
-
-        pos = position or (trade_account.current_position if trade_account is not None else None)
-        trade_price, trade_val, trade_cost = self._calc_trade_info_by_order(order, pos, dealt_order_amount)
-
-        if trade_val > 1e-5:
-            if trade_account is not None:
-                cp = trade_account.current_position
-                if not cp.skip_update():
-                    held = cp.check_stock(order.stock_id)
-                    # Account-level bookkeeping (turnover/cost/returns). Mirrors
-                    # Account._update_state_from_order except for fresh short sales,
-                    # where no prior price exists to compute order profit from.
-                    if order.direction == Order.SELL and not held:
-                        trade_account.accum_info.add_turnover(trade_val)
-                        trade_account.accum_info.add_cost(trade_cost)
-                        trade_account.accum_info.add_return_value(0.0)
-                    if order.direction == Order.SELL:
-                        # sell: update account state first (stock entry may be deleted)
-                        if held:
-                            trade_account._update_state_from_order(order, trade_val, trade_cost, trade_price)
-                        self._position_sell(cp, order, trade_val, trade_cost, trade_price)
-                    else:
-                        # buy: update position first (entry may be created), then account state
-                        # A buy that covers a short to exactly flat deletes the entry inside
-                        # _position_buy; re-seed a transient zero-amount stub so the
-                        # account's order-profit lookup still finds the trade price,
-                        # then drop it (_update_state_from_order never mutates entries).
-                        sid = order.stock_id
-                        had_entry = isinstance(cp.position.get(sid), dict)
-                        self._position_buy(cp, order, trade_val, trade_cost, trade_price)
-                        covered_to_flat = had_entry and not isinstance(cp.position.get(sid), dict)
-                        if covered_to_flat:
-                            cp.position[sid] = {"amount": 0.0, "price": trade_price, "weight": 0}
-                        trade_account._update_state_from_order(order, trade_val, trade_cost, trade_price)
-                        if covered_to_flat:
-                            cp.position.pop(sid, None)
-            elif position is not None:
-                if order.direction == Order.BUY:
-                    self._position_buy(position, order, trade_val, trade_cost, trade_price)
-                else:
-                    self._position_sell(position, order, trade_val, trade_cost, trade_price)
-        return trade_val, trade_cost, trade_price
-
-    # --------------------------- Position mutation helpers ---------------------------
-    def _position_buy(self, position: BasePosition, order: Order, trade_val: float, cost: float, trade_price: float) -> None:
-        """Handle buy order bookkeeping against a BasePosition while supporting shorts.
-
-        Rules implemented (simplified):
-        - If there is an existing short (amount < 0), the buy will first cover the short.
-        - If covering closes the short completely, the remaining buy becomes a long
-        - Cash updates mimic Position._buy_stock/_sell_stock (cash decreases by trade_val+cost for buys)
-        """
-        trade_amount = trade_val / trade_price
-        sid = order.stock_id
-        current_amount = position.get_stock_amount(sid) if position.check_stock(sid) else 0.0
-
-        # covering existing short
-        if current_amount < -1e-12:
-            # amount is negative -> we are short. Buying reduces the short.
-            new_amount = current_amount + trade_amount
-            if abs(new_amount) <= 1e-8:
-                # short fully covered exactly -> remove entry
-                if sid in position.position:
-                    del position.position[sid]
-            elif new_amount > 0:
-                # short fully covered with leftover buy amount -> leftover becomes a long position
-                position.position[sid] = {"amount": new_amount, "price": trade_price, "weight": 0}
-            else:
-                # partially cover
-                position.position[sid]["amount"] = new_amount
-                position.position[sid]["price"] = trade_price
-        else:
-            # normal or increasing long
-            if sid not in position.position or not isinstance(position.position[sid], dict):
-                # initialize stock
-                position.position[sid] = {"amount": trade_amount, "price": trade_price, "weight": 0}
-            else:
-                position.position[sid]["amount"] = position.position[sid].get("amount", 0.0) + trade_amount
-                position.position[sid]["price"] = trade_price
-
-        # cash effect same as Position._buy_stock
-        position.position["cash"] -= trade_val + cost
-
-    def _position_sell(self, position: BasePosition, order: Order, trade_val: float, cost: float, trade_price: float) -> None:
-        """Handle sell order bookkeeping against a BasePosition while supporting shorts.
-
-        Rules implemented (simplified):
-        - If holding enough long shares, sell will reduce/close the long position normally.
-        - If not holding enough long shares and shorts are allowed, the remaining sold amount will create/expand a short position.
-        - Cash update for sells follows Position._sell_stock logic (cash increases by trade_val - cost)
-        """
-        trade_amount = trade_val / trade_price
-        sid = order.stock_id
-        current_amount = position.get_stock_amount(sid) if position.check_stock(sid) else 0.0
-
-        if current_amount > 1e-12:
-            # we have long shares; sell from them first
-            if trade_amount >= current_amount - 1e-8:
-                # selling all or more than holdings
-                # remove long position
-                if sid in position.position:
-                    del position.position[sid]
-                # remaining sold amount becomes short if allowed
-                remain = trade_amount - current_amount
-                if remain > 1e-8:
-                    if not self.allow_short:
-                        # should not happen due to clipping earlier, but guard anyway
-                        raise ValueError(f"Attempt to short {sid} while shorting disabled")
-                    # create short entry
-                    position.position[sid] = {"amount": -remain, "price": trade_price, "weight": 0}
-            else:
-                # partial sell
-                position.position[sid]["amount"] = current_amount - trade_amount
-                position.position[sid]["price"] = trade_price
-        else:
-            # currently flat or already short
-            if not self.allow_short:
-                raise ValueError(f"Attempt to short {sid} while shorting disabled")
-            # expand short
-            new_amount = current_amount - trade_amount
-            if sid not in position.position or not isinstance(position.position[sid], dict):
-                position.position[sid] = {"amount": new_amount, "price": trade_price, "weight": 0}
-            else:
-                position.position[sid]["amount"] = new_amount
-                position.position[sid]["price"] = trade_price
-
-        # cash effect same as Position._sell_stock
-        new_cash = trade_val - cost
-        if getattr(position, "_settle_type", None) == position.ST_CASH:
-            position.position["cash_delay"] = position.position.get("cash_delay", 0.0) + new_cash
-        else:
-            position.position["cash"] = position.position.get("cash", 0.0) + new_cash
-
-    # --------------------------- Borrow availability helpers ---------------------------
-    def is_borrowable(self, stock_id: str, amount: float) -> bool:
-        """Check whether the requested amount is borrowable for the given stock.
-
-        If a borrowable dict is provided, it may contain either booleans or numeric limits (maximum borrowable shares).
-        Symbols absent from the dict follow `borrow_default`.
-        """
-        if not self.allow_short:
-            return False
-        if stock_id not in self.borrowable:
-            return self.borrow_default
-        v = self.borrowable[stock_id]
-        if isinstance(v, bool):
-            return v
-        try:
-            limit = float(v)
-            return amount <= limit
-        except Exception:
-            return True
-

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

@@ -15,9 +15,6 @@ import os
 from inspect import getfullargspec
 from typing import List, Optional, Tuple, Union
 
-import numpy as np
-import pandas as pd
-
 from qlib.data.dataset import processor as processor_module
 from qlib.data.dataset.handler import DataHandlerLP
 from qlib.utils import get_callable_kwargs
@@ -25,7 +22,6 @@ from qlib.utils import get_callable_kwargs
 from ...data.config import (
     LakeConfig,
     timeframe_for_freq,
-    FEATURE_FAMILIES,
     NON_FEATURE_COLUMNS,
 )
 
@@ -96,7 +92,7 @@ def get_common_feature_fields(lake_root=None, market="US", timeframe="1d") -> Li
 
     common: set = set()
     # family tier: features/market=*/timeframe=*/family=*/symbol=*.parquet
-    for fam in FEATURE_FAMILIES:
+    for fam in ("ta", "sp"):
         fam_dir = feat_dir / f"family={fam}"
         if fam_dir.is_dir():
             common |= _family_common(fam_dir)
@@ -147,174 +143,6 @@ class DropAllNaN(processor_module.Processor):
         return df
 
 
-class BenchResidual(processor_module.Processor):
-    """Subtract a benchmark instrument's forward return from the label, per datetime.
-
-    Turns the training target from an absolute-return rank into a *residual* rank:
-    ``r_i - r_bench`` is ranked cross-sectionally by the downstream ``CSRankNorm`` /
-    ``CSZScoreNorm`` processors instead of ``r_i`` alone. Must be inserted BEFORE any
-    per-date normalization so the ranking itself is computed on residual returns
-    (ordering flips exactly where the benchmark trends).
-
-    Stateless: ``fit`` is a no-op and the benchmark forward return is recomputed from
-    the lake parquet on first ``__call__``. Rows whose benchmark value is missing are
-    left untouched. Accepts ``fit_start_time``/``fit_end_time`` (ignored) so
-    ``check_transform_proc`` can inject the fit window uniformly.
-
-    NOTE: under any cross-sectional normalization downstream (``CSRankNorm`` /
-    ``CSZScoreNorm``) this processor is a mathematical no-op: subtracting the same
-    per-date constant preserves ranks, and z-scoring absorbs constant shifts. Use
-    ``BenchBetaResidual`` for a target that actually reorders.
-    """
-
-    def __init__(
-        self,
-        benchmark="SPY",
-        fields_group="label",
-        lake_root=None,
-        market="US",
-        timeframe=None,
-        freq="day",
-        fit_start_time=None,
-        fit_end_time=None,
-    ):
-        self.benchmark = benchmark
-        self.fields_group = fields_group
-        self.lake_root = lake_root
-        self.market = market
-        self.timeframe = timeframe or timeframe_for_freq(freq)
-        self.fit_start_time = fit_start_time
-        self.fit_end_time = fit_end_time
-        self._bench_label = None
-
-    def _load_bench_label(self):
-        if self._bench_label is not None:
-            return self._bench_label
-        cfg = LakeConfig(self.lake_root, self.market)
-        p = cfg.bar_path(self.timeframe, self.benchmark)
-        if not p.exists():
-            raise FileNotFoundError(f"BenchResidual: benchmark bar file not found: {p}")
-        df = pd.read_parquet(p)
-        s = pd.Series(df["c"].astype(float).values, index=pd.to_datetime(df["t"])).sort_index()
-        s.index = s.index.normalize()
-        # mirror Ref($close,-6)/Ref($close,-1)-1 on the benchmark's own calendar
-        bench_label = s.shift(-6) / s.shift(-1) - 1
-        self._bench_label = bench_label[~bench_label.index.duplicated(keep="last")]
-        return self._bench_label
-
-    def fit(self, df=None):
-        return self
-
-    def __call__(self, df):
-        bl = self._load_bench_label()
-        cols = processor_module.get_group_columns(df, self.fields_group)
-        dt = df.index.get_level_values("datetime")
-        aligned = bl.reindex(pd.DatetimeIndex(dt.unique())).reindex(dt)
-        mask = aligned.notna().values
-        out = df.copy()
-        for c in cols:
-            vals = df[c].values
-            res = vals.copy()
-            res[mask] = np.asarray(vals[mask], dtype=float) - aligned[mask].values
-            out[c] = res
-        return out
-
-
-class BenchBetaResidual(processor_module.Processor):
-    """Residualize the label against a beta-scaled benchmark move: ``r_i - b_i * r_bench``.
-
-    Unlike a plain constant subtraction (see ``BenchResidual``), the name-specific rolling
-    beta ``b_i`` makes this survive cross-sectional normalization: in up-weeks high-beta
-    names lose rank, in down-weeks they gain — exactly the relative structure an absolute-
-    return ranking hides.
-
-    Beta is estimated from *past* data only (rolling ``window`` trading days of daily close
-    returns of each instrument vs the benchmark, both read up to and including ``t``), so
-    no lookahead enters the target. The benchmark leg uses the same horizon as the label
-    expression (``Ref($close,-6)/Ref($close,-1)-1`` by default via ``horizon``/``base``,
-    matching the yaml's 6-day label). Rows with missing beta or benchmark values keep
-    their raw label.
-
-    Requires ``$close`` to be present in the feature group (it always is for TACHandler).
-    Stateless; accepts ``fit_start_time``/``fit_end_time`` (ignored) for uniform kwargs
-    injection. Must be inserted BEFORE any per-date normalization processor.
-    """
-
-    def __init__(
-        self,
-        benchmark="SPY",
-        fields_group="label",
-        lake_root=None,
-        market="US",
-        timeframe=None,
-        freq="day",
-        window=63,
-        horizon=6,
-        base=1,
-        feature_field="$close",
-        fit_start_time=None,
-        fit_end_time=None,
-    ):
-        self.benchmark = benchmark
-        self.fields_group = fields_group
-        self.lake_root = lake_root
-        self.market = market
-        self.timeframe = timeframe or timeframe_for_freq(freq)
-        self.window = int(window)
-        self.horizon = int(horizon)
-        self.base = int(base)
-        self.feature_field = feature_field
-        self.fit_start_time = fit_start_time
-        self.fit_end_time = fit_end_time
-        self._bench = None
-
-    def _load_bench_close(self):
-        if self._bench is not None:
-            return self._bench
-        cfg = LakeConfig(self.lake_root, self.market)
-        p = cfg.bar_path(self.timeframe, self.benchmark)
-        if not p.exists():
-            raise FileNotFoundError(f"BenchBetaResidual: benchmark bar file not found: {p}")
-        df = pd.read_parquet(p)
-        s = pd.Series(df["c"].astype(float).values, index=pd.to_datetime(df["t"])).sort_index()
-        s.index = s.index.normalize()
-        self._bench = s[~s.index.duplicated(keep="last")]
-        return self._bench
-
-    def fit(self, df=None):
-        return self
-
-    def __call__(self, df):
-        bench = self._load_bench_close()
-
-        # benchmark forward return over the same horizon as the label expression
-        fwd = bench.shift(-(self.base + self.horizon - 1)) / bench.shift(-self.base) - 1
-
-        px_col = ("feature", self.feature_field)
-        if px_col not in df.columns:
-            raise KeyError(f"BenchBetaResidual: {self.feature_field} not found in features")
-        px = df[px_col].unstack("instrument").sort_index()
-        rets = px / px.shift(1) - 1
-        bret = bench.reindex(px.index).pct_change()
-
-        # rolling beta per instrument using data <= t (no lookahead)
-        cov = rets.rolling(self.window, min_periods=max(10, self.window // 2)).cov(bret)
-        var = bret.rolling(self.window, min_periods=max(10, self.window // 2)).var()
-        beta = cov.div(var, axis=0)
-
-        contrib = beta.mul(fwd.reindex(px.index), axis=0)
-        cols = list(processor_module.get_group_columns(df, self.fields_group))
-        out = df.copy()
-        for c in cols:
-            lab = df[c].unstack("instrument").reindex(px.index)
-            resid = lab - contrib.where(contrib.notna() & lab.notna(), 0.0)
-            new_vals = resid.stack()
-            new_vals.index.names = df.index.names
-            # residual where available, raw label otherwise (e.g. beta warm-up rows)
-            out[c] = new_vals.reindex(out.index).fillna(df[c])
-        return out
-
-
 class TACHandler(DataHandlerLP):
     """DataHandlerLP backed by the TradeAC parquet lake.
 
@@ -417,12 +245,10 @@ class TACHandler(DataHandlerLP):
         return get_common_feature_fields(lake_root, market, timeframe_for_freq(freq))
 
 
-__all__ = ["TACHandler", "DropAllNaN", "BenchResidual", "BenchBetaResidual", "get_common_feature_fields"]
+__all__ = ["TACHandler", "DropAllNaN", "get_common_feature_fields"]
 
 
-# Make `DropAllNaN`/`BenchResidual`/`BenchBetaResidual` resolvable by bare name from processor
+# Make `DropAllNaN` resolvable by bare name from processor configs (e.g. the default
-# configs (e.g. the default ``infer_processors`` and workflow yamls that reference them without a
+# ``infer_processors`` and workflow yamls that reference it without a ``module_path``),
-# ``module_path``), mirroring how qlib registers its own processors in ``qlib.data.dataset.processor``.
+# mirroring how qlib registers its own processors in ``qlib.data.dataset.processor``.
 processor_module.DropAllNaN = DropAllNaN
-processor_module.BenchResidual = BenchResidual
-processor_module.BenchBetaResidual = BenchBetaResidual

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

@@ -1,4 +1,11 @@
+from .ic_gate import ICGateTopkDropoutStrategy  # noqa: F401
 from .optimal_stop import OptimalStopControl  # noqa: F401
-from .long_short import LongShortTopkStrategy  # noqa: F401
+from .regime_gate import RegimeGateTopkDropoutStrategy  # noqa: F401
+from .weekly_rebalance import WeeklyRebalanceDropoutStrategy  # noqa: F401
 
-__all__ = ["OptimalStopControl", "LongShortTopkStrategy"]
+__all__ = [
+    "ICGateTopkDropoutStrategy",
+    "OptimalStopControl",
+    "RegimeGateTopkDropoutStrategy",
+    "WeeklyRebalanceDropoutStrategy",
+]

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

@@ -1,361 +0,0 @@
-"""Long-short Top-K strategy for cross-sectional signals.
-
-Each day the strategy ranks the cross-section by prediction score and rebalances
-to an equal-weight two-sided book: the ``topk`` highest-ranked names go long and
-the ``k_short`` lowest-ranked names go short. Net-new shorts are opened by
-selling beyond current holdings, which requires a short-aware exchange such as
-``tac_qlib.contrib.backtest.tradeac_exchange.TradeACExchange`` with
-``allow_short=True`` (borrow limits, margin requirements and borrow fees are
-enforced there, not here).
-
-Sizing deploys ``equity * risk_degree`` as gross notional split evenly across
-all long and short legs, so the book is approximately market neutral.
-``allow_short=False`` disables the short side entirely (long-only ``topk``).
-
-Short eligibility can be restricted further, with static or dynamic gates:
-``short_whitelist`` limits shorts to an explicit symbol set; ``short_vol_top_pct``
-requires a candidate's trailing realized volatility to rank in the top fraction
-of that day's cross-section; ``short_max_mom`` (falling-knife filter) only
-allows shorting names whose own trailing momentum is at/below a threshold;
-``short_regime_sma`` disables shorts entirely while the benchmark trades above
-its moving average (risk-on). Borrow availability itself is enforced by the
-exchange (``borrowable`` whitelist / per-symbol caps via ``TradeACExchange``).
-
-Wired into qrun workflows like any ``BaseStrategy`` (see ``PortAnaRecord``
-config). Mirrors the API usage of qlib's ``TopkDropoutStrategy``: ``Order`` /
-``OrderDir`` from ``qlib.backtest.decision``, ``trade_calendar`` /
-``trade_exchange`` / ``trade_position`` injected by the backtest executor.
-"""
-
-from __future__ import annotations
-
-import copy
-from typing import Dict, List, Optional
-
-import pandas as pd
-
-from qlib.backtest import Order
-from qlib.backtest.decision import OrderDir, TradeDecisionWO
-from qlib.contrib.strategy.signal_strategy import BaseSignalStrategy
-from qlib.log import get_module_logger
-
-__all__ = ["LongShortTopkStrategy"]
-
-
-class LongShortTopkStrategy(BaseSignalStrategy):
-    """Equal-weight long-short Top-K strategy over a cross-sectional signal.
-
-    Parameters
-    ----------
-    topk : number of long legs (highest-ranked names).
-    k_short : number of short legs (lowest-ranked names).
-    hold_thresh : minimum holding days before a leg may be closed/reduced.
-    only_tradable : only select candidates tradable on the trade date.
-    rebalance_tol : skip rebalances smaller than this fraction of a leg's
-        target notional (turnover control).
-    allow_short : enable/disable the short side. With ``False`` the bottom-ranked
-        legs are dropped and the book is long-only ``topk``; pair with
-        ``allow_short=False`` on the exchange for a fully borrow-free run.
-        Legacy alias ``enable_short`` is accepted.
-    short_whitelist : optional list of symbols eligible for shorting; candidates
-        outside the list are skipped (``None`` = all names eligible).
-    short_vol_window : trailing window (trading days) for realized-vol estimation.
-    short_vol_top_pct : if set, a short candidate's trailing realized volatility
-        must rank at or above this percentile of that day's cross-section
-        (e.g. ``0.5`` = only the more volatile half may be shorted). Candidates
-        without measurable vol are never shorted.
-    short_mom_window : trailing window (trading days) for the candidate momentum
-        used by the falling-knife gate.
-    short_max_mom : if set, a candidate's trailing ``short_mom_window``-day return
-        must be <= this value to be shortable (e.g. ``0.0`` = only short names
-        that are actually falling). Candidates without measurable momentum are
-        never shorted.
-    short_regime_symbol : benchmark symbol for the regime gate (default SPY).
-    short_regime_sma : if set, shorts are only allowed on days where the regime
-        symbol's last close (strictly before the execution bar) is BELOW its
-        ``short_regime_sma``-day moving average — i.e. shorts are disabled in
-        risk-on regimes and enabled in drawdowns.
-    """
-
-    def __init__(
-        self,
-        *,
-        signal=None,
-        topk: int = 4,
-        k_short: int = 2,
-        hold_thresh: int = 1,
-        only_tradable: bool = True,
-        rebalance_tol: float = 0.05,
-        allow_short: Optional[bool] = None,
-        enable_short: Optional[bool] = None,
-        short_whitelist: Optional[List[str]] = None,
-        short_vol_window: int = 20,
-        short_vol_top_pct: Optional[float] = None,
-        short_mom_window: int = 20,
-        short_max_mom: Optional[float] = None,
-        short_regime_symbol: str = "SPY",
-        short_regime_sma: Optional[int] = None,
-        risk_degree: float = 0.95,
-        trade_exchange=None,
-        level_infra=None,
-        common_infra=None,
-        **kwargs,
-    ):
-        super().__init__(
-            signal=signal,
-            risk_degree=risk_degree,
-            trade_exchange=trade_exchange,
-            level_infra=level_infra,
-            common_infra=common_infra,
-            **kwargs,
-        )
-        if allow_short is None:
-            allow_short = True if enable_short is None else bool(enable_short)
-        self.allow_short = bool(allow_short)
-        self.topk = topk
-        self.k_short = k_short
-        self.hold_thresh = hold_thresh
-        self.only_tradable = only_tradable
-        self.rebalance_tol = rebalance_tol
-        self.short_whitelist = set(short_whitelist) if short_whitelist is not None else None
-        if not 0 < float(short_vol_window) <= 1000:
-            raise ValueError(f"short_vol_window must be in (0, 1000], got {short_vol_window}")
-        self.short_vol_window = int(short_vol_window)
-        if short_vol_top_pct is not None and not 0.0 < float(short_vol_top_pct) <= 1.0:
-            raise ValueError(f"short_vol_top_pct must be in (0, 1], got {short_vol_top_pct}")
-        self.short_vol_top_pct = None if short_vol_top_pct is None else float(short_vol_top_pct)
-        if not 0 < float(short_mom_window) <= 1000:
-            raise ValueError(f"short_mom_window must be in (0, 1000], got {short_mom_window}")
-        self.short_mom_window = int(short_mom_window)
-        self.short_max_mom = None if short_max_mom is None else float(short_max_mom)
-        self.short_regime_symbol = str(short_regime_symbol)
-        if short_regime_sma is not None and not 1 < int(short_regime_sma) <= 1000:
-            raise ValueError(f"short_regime_sma must be in (1, 1000], got {short_regime_sma}")
-        self.short_regime_sma = None if short_regime_sma is None else int(short_regime_sma)
-        # per-day caches (keyed by trade date)
-        self._vol_cache_key: Optional[str] = None
-        self._vol_cache_val: Dict[str, Dict[str, float]] = {}
-        self._regime_cache: Dict[str, bool] = {}
-
-    # ------------------------------------------------------------------ utils
-    def _is_tradable(self, code, start, end) -> bool:
-        if not self.only_tradable:
-            return True
-        try:
-            return self.trade_exchange.is_stock_tradable(stock_id=code, start_time=start, end_time=end)
-        except TypeError:
-            return True
-
-    def _mark_price(self, code, start, end) -> Optional[float]:
-        try:
-            px = self.trade_exchange.get_deal_price(
-                stock_id=code, start_time=start, end_time=end, direction=OrderDir.BUY
-            )
-        except (KeyError, ValueError):
-            return None
-        if px is None or px != px or px <= 0:
-            return None
-        return float(px)
-
-    def _day_stats(self, codes: List[str], trade_start) -> Dict[str, Dict[str, float]]:
-        """Per-day cross-sectional stats used by the dynamic short gates.
-
-        For each code, returns ``{"vol_rank": r}`` (percentile of trailing
-        realized vol over ``short_vol_window`` bars across that day's
-        cross-section) when the vol gate is on, and ``{"mom": m}`` (trailing
-        ``short_mom_window``-bar return) when the falling-knife gate is on.
-        All series end on the last bar strictly BEFORE the execution bar (no
-        lookahead). Codes without measurable data are simply absent — such
-        candidates are never shorted (fail-closed).
-        """
-        if self.short_vol_top_pct is None and self.short_max_mom is None:
-            return {}
-        key = str(pd.Timestamp(trade_start))
-        if self._vol_cache_key == key:
-            return self._vol_cache_val
-        out: Dict[str, Dict[str, float]] = {}
-        try:
-            from qlib.data import D
-
-            end = pd.Timestamp(trade_start)
-            buf = max(self.short_vol_window, self.short_mom_window) * 3 + 30
-            df = D.features(
-                sorted(codes),
-                ["$close"],
-                start_time=end - pd.Timedelta(days=buf),
-                end_time=end - pd.Timedelta(days=1),
-            )
-            close = df["$close"].unstack(level="instrument") if isinstance(df.index, pd.MultiIndex) else df["$close"]
-            if self.short_vol_top_pct is not None:
-                vol = close.pct_change().rolling(self.short_vol_window).std().iloc[-1]
-                for code, rank in vol.rank(pct=True).dropna().items():
-                    out.setdefault(str(code), {})["vol_rank"] = float(rank)
-            if self.short_max_mom is not None:
-                w = min(self.short_mom_window, len(close) - 1)
-                mom = close.iloc[-1] / close.iloc[-(w + 1)] - 1
-                for code, m in mom.items():
-                    if m == m:
-                        out.setdefault(str(code), {})["mom"] = float(m)
-        except Exception as e:  # noqa: BLE001 - degrade to fail-closed (no shorts)
-            get_module_logger(self.__class__.__name__).warning(
-                f"short gates unavailable ({type(e).__name__}: {e}); no shorts this step"
-            )
-        self._vol_cache_key, self._vol_cache_val = key, out
-        return out
-
-    def _regime_ok(self, trade_start) -> bool:
-        """True when shorting is allowed by the benchmark-regime gate.
-
-        With ``short_regime_sma`` set, shorts are permitted only while the
-        regime symbol's last close strictly before the execution bar sits below
-        its moving average (risk-off). Data failure fails closed (no shorts).
-        """
-        if self.short_regime_sma is None:
-            return True
-        key = str(pd.Timestamp(trade_start))
-        cached = self._regime_cache.get(key)
-        if cached is not None:
-            return cached
-        ok = False
-        try:
-            from qlib.data import D
-
-            end = pd.Timestamp(trade_start)
-            df = D.features(
-                [self.short_regime_symbol],
-                ["$close"],
-                start_time=end - pd.Timedelta(days=int(self.short_regime_sma * 3 + 30)),
-                end_time=end - pd.Timedelta(days=1),
-            )
-            s = df["$close"]
-            if isinstance(s.index, pd.MultiIndex):
-                s = s.droplevel("instrument")
-            sma = s.rolling(self.short_regime_sma).mean().iloc[-1]
-            px = s.iloc[-1]
-            ok = bool(px < sma)
-        except Exception as e:  # noqa: BLE001 - degrade to fail-closed (no shorts)
-            get_module_logger(self.__class__.__name__).warning(
-                f"regime gate unavailable ({type(e).__name__}: {e}); no shorts this step"
-            )
-        self._regime_cache[key] = ok
-        return ok
-
-    # ------------------------------------------------------------- decision
-    def generate_trade_decision(self, execute_result=None):
-        trade_step = self.trade_calendar.get_trade_step()
-        trade_start, trade_end = self.trade_calendar.get_step_time(trade_step)
-        pred_start, pred_end = self.trade_calendar.get_step_time(trade_step, shift=1)
-        pred_score = self.signal.get_signal(start_time=pred_start, end_time=pred_end)
-        if isinstance(pred_score, pd.DataFrame):
-            pred_score = pred_score.iloc[:, 0]
-        if pred_score is None or len(pred_score) == 0:
-            return TradeDecisionWO([], self)
-        pred_score = pred_score.dropna()
-        if pred_score.empty:
-            return TradeDecisionWO([], self)
-
-        time_per_step = self.trade_calendar.get_freq()
-        current_temp = copy.deepcopy(self.trade_position)
-
-        # ---- signed current holdings ---------------------------------------
-        cur_amount: Dict[str, float] = {}
-        for code in current_temp.get_stock_list():
-            amt = float(current_temp.get_stock_amount(code))
-            if abs(amt) > 1e-6:
-                cur_amount[code] = amt
-
-        # ---- targets: top-k long, bottom-k_short short ----------------------
-        ranked = list(pred_score.sort_values(ascending=False).index)
-        longs: List[str] = []
-        for code in ranked:
-            if len(longs) >= self.topk:
-                break
-            if self._is_tradable(code, trade_start, trade_end):
-                longs.append(code)
-        shorts: List[str] = []
-        if self.allow_short and self._regime_ok(trade_start):
-            stats = self._day_stats(list(ranked), trade_start)
-            for code in reversed(ranked):
-                if len(shorts) >= self.k_short:
-                    break
-                if code in longs:
-                    continue
-                if not self._is_tradable(code, trade_start, trade_end):
-                    continue
-                if self.short_whitelist is not None and code not in self.short_whitelist:
-                    continue
-                st = stats.get(code)
-                if self.short_vol_top_pct is not None:
-                    rank = None if st is None else st.get("vol_rank")
-                    if rank is None or rank < self.short_vol_top_pct:
-                        continue
-                if self.short_max_mom is not None:
-                    mom = None if st is None else st.get("mom")
-                    if mom is None or mom > self.short_max_mom:
-                        continue
-                shorts.append(code)
-
-        # ---- marks & equity --------------------------------------------------
-        marks: Dict[str, float] = {}
-        for code in set(cur_amount) | set(longs) | set(shorts):
-            px = self._mark_price(code, trade_start, trade_end)
-            if px is not None:
-                marks[code] = px
-
-        equity = current_temp.get_cash()
-        for code, amt in cur_amount.items():
-            if code in marks:
-                equity += amt * marks[code]
-        if equity <= 0:
-            return TradeDecisionWO([], self)
-
-        n_legs = len([c for c in longs if c in marks]) + len([c for c in shorts if c in marks])
-        if n_legs == 0:
-            return TradeDecisionWO([], self)
-        per_leg = equity * self.risk_degree / n_legs
-
-        target_signed: Dict[str, float] = {}
-        for code in longs:
-            if code in marks:
-                target_signed[code] = per_leg / marks[code]
-        for code in shorts:
-            if code in marks:
-                target_signed[code] = -(per_leg / marks[code])
-
-        # ---- order generation -------------------------------------------------
-        sell_orders: List[Order] = []
-        buy_orders: List[Order] = []
-
-        def submit(code: str, amount: float, direction: int) -> None:
-            factor = self.trade_exchange.get_factor(stock_id=code, start_time=trade_start, end_time=trade_end)
-            amount = self.trade_exchange.round_amount_by_trade_unit(amount, factor)
-            if amount <= 1e-6:
-                return
-            o = Order(stock_id=code, amount=amount, start_time=trade_start, end_time=trade_end, direction=direction)
-            if self.trade_exchange.check_order(o):
-                (buy_orders if direction == Order.BUY else sell_orders).append(o)
-
-        # close holdings that are no longer targeted (frees cash / unwinds shorts)
-        for code, amt in cur_amount.items():
-            if code in target_signed:
-                continue
-            if marks.get(code) is None:
-                continue
-            if current_temp.get_stock_count(code, bar=time_per_step) < self.hold_thresh:
-                continue
-            submit(code, abs(amt), Order.SELL if amt > 0 else Order.BUY)
-
-        # rebalance targeted legs toward their signed target quantity
-        for code, tgt in target_signed.items():
-            cur = cur_amount.get(code, 0.0)
-            delta = tgt - cur
-            if abs(delta * marks[code]) < max(self.rebalance_tol * per_leg, 1.0):
-                continue
-            if delta > 0:
-                submit(code, delta, Order.BUY)
-            else:
-                if cur > 0 and current_temp.get_stock_count(code, bar=time_per_step) < self.hold_thresh:
-                    continue
-                submit(code, -delta, Order.SELL)
-
-        return TradeDecisionWO(sell_orders + buy_orders, 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/weekly_rebalance.py

@@ -37,20 +37,11 @@ class WeeklyRebalanceDropoutStrategy(TopkDropoutStrategy):
     forbid_all_trade_at_limit : same as ``TopkDropoutStrategy``.
     hold_band_pct : skip order for a name whose deviation from target weight is
         below this fraction of the target (no-trade buffer band).
-    rebalance_every_n_weeks : rebalance every N ISO weeks instead of every week
-        (default 1 = weekly; 2 = biweekly).  Ignored when
-        ``rebalance_every_n_days`` is set.
-    rebalance_every_n_days : rebalance every N trading days (daily when N=1).
-        When set, overrides the weekly gating logic entirely.
     """
 
-    def __init__(self, *, topk, n_drop, hold_band_pct: float = DEFAULT_HOLD_BAND_PCT,
+    def __init__(self, *, topk, n_drop, hold_band_pct: float = DEFAULT_HOLD_BAND_PCT, **kwargs):
-                 rebalance_every_n_weeks: int = 1,
-                 rebalance_every_n_days: int = 0, **kwargs):
         super().__init__(topk=topk, n_drop=n_drop, **kwargs)
         self.hold_band_pct = hold_band_pct
-        self.rebalance_every_n_weeks = rebalance_every_n_weeks
-        self.rebalance_every_n_days = rebalance_every_n_days
 
     @staticmethod
     def _iso_week(ts) -> tuple:
@@ -62,25 +53,13 @@ class WeeklyRebalanceDropoutStrategy(TopkDropoutStrategy):
         trade_step = self.trade_calendar.get_trade_step()
         trade_start_time, trade_end_time = self.trade_calendar.get_step_time(trade_step)
 
-        if self.rebalance_every_n_days > 0:
+        cur_week = self._iso_week(trade_start_time)
-            # daily gating: count trading steps since last rebalance
+        prev_week = getattr(self, "_last_week", None)
-            step_num = trade_step
+        self._last_week = cur_week
-            if hasattr(self, "_last_rebal_step"):
-                if (step_num - self._last_rebal_step) < self.rebalance_every_n_days:
-                    return TradeDecisionWO([], self)
-            self._last_rebal_step = step_num
-        else:
-            cur_week = self._iso_week(trade_start_time)
-            prev_week = getattr(self, "_last_week", None)
-            self._last_week = cur_week
 
-            if prev_week is not None and prev_week == cur_week:
+        if prev_week is not None and prev_week == cur_week:
-                return TradeDecisionWO([], self)
+            # not the first trading day of this ISO week -> hold
-
+            return TradeDecisionWO([], self)
-            if self.rebalance_every_n_weeks > 1:
-                week_num = cur_week[1]
-                if prev_week is not None and (week_num % self.rebalance_every_n_weeks) != 1:
-                    return TradeDecisionWO([], self)
 
         pred_start_time, pred_end_time = self.trade_calendar.get_step_time(trade_step, shift=1)
         pred_score = self.signal.get_signal(start_time=pred_start_time, end_time=pred_end_time)

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

@@ -61,11 +61,6 @@ UNKNOWN_FIELD_NAMES = ("factor", "change", "trade_unit", "suspend_flag")
 #: columns in the parquet files that are not features
 NON_FEATURE_COLUMNS = ("t", "date", "market", "timeframe", "symbol")
 
-#: Feature-family partitions merged by ``LakeConfig.load_features`` and scanned
-#: by the handler's field discovery. ``macro`` holds broadcast market-state
-#: columns (see skills/tac-qlib-custom/examples/persist_macro_broadcast.py).
-FEATURE_FAMILIES = ("ta", "sp", "macro")
-
 
 def timeframe_for_freq(freq: str) -> str:
     """Map a qlib frequency (e.g. ``day``, ``1min``) to a lake timeframe (e.g. ``1d``)."""
@@ -118,12 +113,12 @@ class LakeConfig:
         return self.features_dir(timeframe) / f"symbol={str(symbol).upper()}.parquet"
 
     def load_features(self, timeframe: str, symbol: str) -> pd.DataFrame:
-        """All feature columns for a symbol, merging the `family=ta|sp|macro`
+        """All feature columns for a symbol, merging the `family=ta` and
-        partitions by timestamp. Returns an empty frame when no
+        `family=sp` partitions by timestamp. Returns an empty frame when no
         feature files exist (legacy flat layout falls back transparently)."""
         sym = str(symbol).upper()
         frames = []
-        for family in FEATURE_FAMILIES:
+        for family in ("ta", "sp"):
             p = self.features_dir(timeframe) / f"family={family}" / f"symbol={sym}.parquet"
             if p.exists():
                 frames.append(pd.read_parquet(p))