start experiment 61 (exp/61-scheduled-algo-retrain-on-2026-08-24-tac)

code/MANIFEST.txt

@@ -1,29 +1,34 @@
 # TradeAC custom-qlib-code snapshot (auto-generated)
-# parent repo HEAD : f4f6e9291b1bdc69373d06710aa5f9aa396e900c
+# parent repo HEAD : ee5aa8e73c5286860d3ec1dfa6001bf0f8b6690d
 #   tac-qlib/tac_qlib/contrib
 #   tac-qlib/tac_qlib/data
 # per-file hashes (git hash-object):
   1b6298c4a5652f2e863cbdc385a1014a570fcd59  tac-qlib/tac_qlib/contrib/__init__.py
-  861592c63edd6a0853a9cb174b5970435b135fc8  tac-qlib/tac_qlib/contrib/__pycache__/__init__.cpython-312.pyc
+  e21663470e4ab108691392c3f0bcff0a3e7fe459  tac-qlib/tac_qlib/contrib/__pycache__/__init__.cpython-312.pyc
+  2224424d0ff193be4f55d1b791f8fce89439c5d2  tac-qlib/tac_qlib/contrib/backtest/__init__.py
+  0bf40dee440ddbded357d7bbb4efc67c62c4b084  tac-qlib/tac_qlib/contrib/backtest/tradeac_exchange.py
   c76a9f17f680e74eea766eff27f7624359749ed6  tac-qlib/tac_qlib/contrib/data/__init__.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
+  a5c6952e9c8bab2c83fd8030416999726aea73d9  tac-qlib/tac_qlib/contrib/data/__pycache__/__init__.cpython-312.pyc
+  39f148bef96fcce8f548d74c6d338eccdc4145e3  tac-qlib/tac_qlib/contrib/data/__pycache__/handler.cpython-312.pyc
+  fc3d01d530d4e84b3386614b6ac94324e811920e  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
+  f76257db439b030d84ecea2b8ae67079bae4dc6f  tac-qlib/tac_qlib/contrib/model/__pycache__/__init__.cpython-312.pyc
+  858f5fcbe285642569c214d5803edbae1e5dfa1e  tac-qlib/tac_qlib/contrib/model/__pycache__/rank_ensemble.cpython-312.pyc
+  7de125f7f263c554b3337138c760d44394b4824a  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
-  b68a974a0bc87a279caed90cf2be4d7e78f9e59f  tac-qlib/tac_qlib/contrib/strategy/__init__.py
-  c29e45e562256bf786c36f91a971b097467276e9  tac-qlib/tac_qlib/contrib/strategy/__pycache__/__init__.cpython-312.pyc
-  6dd1c568a2961842793674390d5abffd1a0e71b8  tac-qlib/tac_qlib/contrib/strategy/__pycache__/optimal_stop.cpython-312.pyc
-  519a1f4c05dbe0ac018ab8b779eb33d53b4dd545  tac-qlib/tac_qlib/contrib/strategy/ic_gate.py
+  184f80da8edf944bad3c8fb4d4d3d189bf4f082b  tac-qlib/tac_qlib/contrib/strategy/__init__.py
+  6893c2097f0de110909f3f5076ac1c32ac5b742b  tac-qlib/tac_qlib/contrib/strategy/__pycache__/__init__.cpython-312.pyc
+  423ec5cd15b273c119ba3b1d7dc7467fc6ba41c4  tac-qlib/tac_qlib/contrib/strategy/__pycache__/long_short.cpython-312.pyc
+  b6b3238699337d559868cb5f8e0c3e900e5da0cf  tac-qlib/tac_qlib/contrib/strategy/__pycache__/optimal_stop.cpython-312.pyc
+  896ef74ae47bcd1ed388e1e5d9c8d70c28097fe9  tac-qlib/tac_qlib/contrib/strategy/kelly_dropout.py
+  9090fc6dfbd339f2f4df4b0c9b87f400ecb5c9d5  tac-qlib/tac_qlib/contrib/strategy/long_short.py
   79aaad9e39fcc740a773f4f63c512ce1086cfde0  tac-qlib/tac_qlib/contrib/strategy/optimal_stop.py
+  5b9acfb4340111b204249add7760bd53c6ae03f1  tac-qlib/tac_qlib/contrib/strategy/regime_gate.py
   fe60bacdfedd48617863be31f24b7c7daebfac5a  tac-qlib/tac_qlib/contrib/strategy/weekly_rebalance.py
   92e6e90eb0cd0a25142034560f27adb6b705b1a8  tac-qlib/tac_qlib/data/__init__.py
-  316bf4aa160cc8d15929ea648be03f4b4999667d  tac-qlib/tac_qlib/data/__pycache__/__init__.cpython-312.pyc
-  554a3f29d181b64effbf49a8161b32e7f93d8d3e  tac-qlib/tac_qlib/data/__pycache__/config.cpython-312.pyc
-  8b47f6d78ac046b6b7b2fb07bd7f3382773ffb73  tac-qlib/tac_qlib/data/__pycache__/providers.cpython-312.pyc
-  53c9007a928841fd3c3b08450f9a6520ce1ac091  tac-qlib/tac_qlib/data/config.py
+  fa1090eb6f17b1b7835038e35fac86334294d165  tac-qlib/tac_qlib/data/__pycache__/__init__.cpython-312.pyc
+  48629a1f51bd4058036ce78d79ed49454982c051  tac-qlib/tac_qlib/data/__pycache__/config.cpython-312.pyc
+  ad7c9b726c9c52773fa82031fcd681337be97fa8  tac-qlib/tac_qlib/data/__pycache__/providers.cpython-312.pyc
+  1953fb2a6371525db7f7b0e1c9dfbf3492d82110  tac-qlib/tac_qlib/data/config.py
   8d0644f6f0d1efb94798ed444cc73e63b643459b  tac-qlib/tac_qlib/data/providers.py

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

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

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

@@ -0,0 +1,432 @@
+# 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

@@ -22,6 +22,7 @@ from qlib.utils import get_callable_kwargs
 from ...data.config import (
     LakeConfig,
     timeframe_for_freq,
+    FEATURE_FAMILIES,
     NON_FEATURE_COLUMNS,
 )
 
@@ -92,7 +93,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 ("ta", "sp"):
+    for fam in FEATURE_FAMILIES:
         fam_dir = feat_dir / f"family={fam}"
         if fam_dir.is_dir():
             common |= _family_common(fam_dir)

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

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

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

@@ -1,117 +0,0 @@
-"""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

@@ -0,0 +1,201 @@
+"""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

@@ -0,0 +1,361 @@
+"""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

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

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

@@ -61,6 +61,11 @@ 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``)."""
@@ -113,12 +118,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` and
-        `family=sp` partitions by timestamp. Returns an empty frame when no
+        """All feature columns for a symbol, merging the `family=ta|sp|macro`
+        partitions by timestamp. Returns an empty frame when no
         feature files exist (legacy flat layout falls back transparently)."""
         sym = str(symbol).upper()
         frames = []
-        for family in ("ta", "sp"):
+        for family in FEATURE_FAMILIES:
             p = self.features_dir(timeframe) / f"family={family}" / f"symbol={sym}.parquet"
             if p.exists():
                 frames.append(pd.read_parquet(p))

workflows/bt-3x3-windows/A-weekly_2024.yaml

@@ -1,95 +0,0 @@
-# Walk-forward: A-weekly / test 2024
-# 3x3 re-validation (trace exp 52). Strategy WeeklyRebalanceDropoutStrategy n_drop=1, parallel=5.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-3x3-windows" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2025-01-07"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2023-08-31"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2023-08-31" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2023-08-31" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2016-01-04", "2023-08-31"]
-                valid: ["2023-09-01", "2023-12-29"]
-                test:  ["2024-01-02", "2024-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: WeeklyRebalanceDropoutStrategy
-                      module_path: tac_qlib.contrib.strategy.weekly_rebalance
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2024-01-02"
-                      end_time: "2024-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-3x3-windows/A-weekly_2025.yaml

@@ -1,95 +0,0 @@
-# Walk-forward: A-weekly / test 2025
-# 3x3 re-validation (trace exp 52). Strategy WeeklyRebalanceDropoutStrategy n_drop=1, parallel=5.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-3x3-windows" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-01-07"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2024-08-30"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2016-01-04", "2024-08-30"]
-                valid: ["2024-09-03", "2024-12-31"]
-                test:  ["2025-01-02", "2025-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: WeeklyRebalanceDropoutStrategy
-                      module_path: tac_qlib.contrib.strategy.weekly_rebalance
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2025-01-02"
-                      end_time: "2025-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-3x3-windows/A-weekly_2026.yaml

@@ -1,95 +0,0 @@
-# Walk-forward: A-weekly / test 2026
-# 3x3 re-validation (trace exp 52). Strategy WeeklyRebalanceDropoutStrategy n_drop=1, parallel=5.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-3x3-windows" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-08-19"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2025-09-01"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2016-01-04", "2025-09-01"]
-                valid: ["2025-09-03", "2026-01-03"]
-                test:  ["2026-01-04", "2026-08-19"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: WeeklyRebalanceDropoutStrategy
-                      module_path: tac_qlib.contrib.strategy.weekly_rebalance
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2026-01-04"
-                      end_time: "2026-08-19"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-3x3-windows/B-moments_2024.yaml

@@ -1,95 +0,0 @@
-# Walk-forward: B-moments / test 2024
-# 3x3 re-validation (trace exp 52). Strategy TopkDropoutStrategy n_drop=1, parallel=default(auto).
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-3x3-windows" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2025-01-07"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2023-08-31"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_5,sp_dsv_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2023-08-31" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2023-08-31" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2016-01-04", "2023-08-31"]
-                valid: ["2023-09-01", "2023-12-29"]
-                test:  ["2024-01-02", "2024-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2024-01-02"
-                      end_time: "2024-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-3x3-windows/B-moments_2025.yaml

@@ -1,95 +0,0 @@
-# Walk-forward: B-moments / test 2025
-# 3x3 re-validation (trace exp 52). Strategy TopkDropoutStrategy n_drop=1, parallel=default(auto).
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-3x3-windows" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-01-07"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2024-08-30"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_5,sp_dsv_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2016-01-04", "2024-08-30"]
-                valid: ["2024-09-03", "2024-12-31"]
-                test:  ["2025-01-02", "2025-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2025-01-02"
-                      end_time: "2025-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-3x3-windows/C-ndrop2_2025.yaml

@@ -1,95 +0,0 @@
-# Walk-forward: C-ndrop2 / test 2025
-# 3x3 re-validation (trace exp 52). Strategy TopkDropoutStrategy n_drop=2, parallel=5.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-3x3-windows" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-01-07"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2024-08-30"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2016-01-04", "2024-08-30"]
-                valid: ["2024-09-03", "2024-12-31"]
-                test:  ["2025-01-02", "2025-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 2, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2025-01-02"
-                      end_time: "2025-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-2021-2023/m2-sharpe22_2021.yaml

@@ -1,96 +0,0 @@
-# Walk-forward transfer test: m2-sharpe22 / test 2021 (trace exp 54)
-# Label-regime match to 2026 (psi 0.039). Strategy TopkDropoutStrategy n_drop=1, parallel=5.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-2021-2023" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2022-01-07"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2020-08-31"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2020-08-31" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2020-08-31" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2016-01-04", "2020-08-31"]
-                valid: ["2020-09-01", "2020-12-31"]
-                test:  ["2021-01-04", "2021-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2021-01-04"
-                      end_time: "2021-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-2021-2023/m2-sharpe22_2023.yaml

@@ -1,96 +0,0 @@
-# Walk-forward transfer test: m2-sharpe22 / test 2023 (trace exp 54)
-# Best label-regime match to 2026 (psi 0.028). Strategy TopkDropoutStrategy n_drop=1, parallel=5.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-2021-2023" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2024-01-07"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2022-08-31"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2022-08-31" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2022-08-31" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2016-01-04", "2022-08-31"]
-                valid: ["2022-09-01", "2022-12-30"]
-                test:  ["2023-01-03", "2023-12-29"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2023-01-03"
-                      end_time: "2023-12-29"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-3w/m2-sharpe22_2024.yaml

@@ -1,96 +0,0 @@
-# Walk-forward: m2-sharpe22 / test 2024 (trace exp 53, ref exp32 c7c12228 on cleaned lake)
-# Strategy TopkDropoutStrategy n_drop=1, parallel=5.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-3windows" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2025-01-07"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2023-08-31"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2023-08-31" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2023-08-31" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2016-01-04", "2023-08-31"]
-                valid: ["2023-09-01", "2023-12-29"]
-                test:  ["2024-01-02", "2024-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2024-01-02"
-                      end_time: "2024-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-3w/m2-sharpe22_2025.yaml

@@ -1,96 +0,0 @@
-# Walk-forward: m2-sharpe22 / test 2025 (trace exp 53, ref exp32 c7c12228 on cleaned lake)
-# Strategy TopkDropoutStrategy n_drop=1, parallel=5.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-3windows" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-01-07"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2024-08-30"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2016-01-04", "2024-08-30"]
-                valid: ["2024-09-03", "2024-12-31"]
-                test:  ["2025-01-02", "2025-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2025-01-02"
-                      end_time: "2025-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-adaptive/m2-sharpe22_1y_2021.yaml

@@ -1,96 +0,0 @@
-# Adaptive short-window retrain: m2-sharpe22 / test 2021 (trace exp 55) — 1y training window
-# Hypothesis: a short recent training window adapts to the target year's regime and transfers the edge.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-adaptive-1y" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2022-01-07"
-                    fit_start_time: "2019-08-30"
-                    fit_end_time: "2020-08-31"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2019-08-30", fit_end_time: "2020-08-31" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2019-08-30", fit_end_time: "2020-08-31" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2019-08-30", "2020-08-31"]
-                valid: ["2020-09-01", "2020-12-31"]
-                test:  ["2021-01-04", "2021-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2021-01-04"
-                      end_time: "2021-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-adaptive/m2-sharpe22_1y_2023.yaml

@@ -1,96 +0,0 @@
-# Adaptive short-window retrain: m2-sharpe22 / test 2023 (trace exp 55) — 1y training window
-# Hypothesis: a short recent training window adapts to the target year's regime and transfers the edge.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-adaptive-1y" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2024-01-07"
-                    fit_start_time: "2021-08-31"
-                    fit_end_time: "2022-08-31"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2021-08-31", fit_end_time: "2022-08-31" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2021-08-31", fit_end_time: "2022-08-31" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2021-08-31", "2022-08-31"]
-                valid: ["2022-09-01", "2022-12-30"]
-                test:  ["2023-01-03", "2023-12-29"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2023-01-03"
-                      end_time: "2023-12-29"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-adaptive/m2-sharpe22_1y_2024.yaml

@@ -1,96 +0,0 @@
-# Adaptive short-window retrain: m2-sharpe22 / test 2024 (trace exp 55) — 1y training window
-# Hypothesis: a short recent training window adapts to the target year's regime and transfers the edge.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-adaptive-1y" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2025-01-07"
-                    fit_start_time: "2022-08-31"
-                    fit_end_time: "2023-08-31"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2022-08-31", fit_end_time: "2023-08-31" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2022-08-31", fit_end_time: "2023-08-31" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2022-08-31", "2023-08-31"]
-                valid: ["2023-09-01", "2023-12-29"]
-                test:  ["2024-01-02", "2024-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2024-01-02"
-                      end_time: "2024-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-adaptive/m2-sharpe22_1y_2025.yaml

@@ -1,96 +0,0 @@
-# Adaptive short-window retrain: m2-sharpe22 / test 2025 (trace exp 55) — 1y training window
-# Hypothesis: a short recent training window adapts to the target year's regime and transfers the edge.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-adaptive-1y" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-01-07"
-                    fit_start_time: "2023-08-31"
-                    fit_end_time: "2024-08-30"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2023-08-31", fit_end_time: "2024-08-30" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2023-08-31", fit_end_time: "2024-08-30" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2023-08-31", "2024-08-30"]
-                valid: ["2024-09-03", "2024-12-31"]
-                test:  ["2025-01-02", "2025-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2025-01-02"
-                      end_time: "2025-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-adaptive/m2-sharpe22_1y_2026.yaml

@@ -1,96 +0,0 @@
-# Adaptive short-window retrain: m2-sharpe22 / test 2026 (trace exp 55) — 1y training window
-# Hypothesis: a short recent training window adapts to the target year's regime and transfers the edge.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-adaptive-1y" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-08-10"
-                    fit_start_time: "2024-09-03"
-                    fit_end_time: "2025-09-01"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2024-09-03", fit_end_time: "2025-09-01" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2024-09-03", fit_end_time: "2025-09-01" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2024-09-03", "2025-09-01"]
-                valid: ["2025-09-03", "2026-01-03"]
-                test:  ["2026-01-04", "2026-08-10"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2026-01-04"
-                      end_time: "2026-08-10"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-adaptive/m2-sharpe22_2y_2021.yaml

@@ -1,96 +0,0 @@
-# Adaptive short-window retrain: m2-sharpe22 / test 2021 (trace exp 55) — 2y training window
-# Hypothesis: a short recent training window adapts to the target year's regime and transfers the edge.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-adaptive-2y" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2022-01-07"
-                    fit_start_time: "2018-08-31"
-                    fit_end_time: "2020-08-31"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2018-08-31", fit_end_time: "2020-08-31" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2018-08-31", fit_end_time: "2020-08-31" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2018-08-31", "2020-08-31"]
-                valid: ["2020-09-01", "2020-12-31"]
-                test:  ["2021-01-04", "2021-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2021-01-04"
-                      end_time: "2021-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-adaptive/m2-sharpe22_2y_2023.yaml

@@ -1,96 +0,0 @@
-# Adaptive short-window retrain: m2-sharpe22 / test 2023 (trace exp 55) — 2y training window
-# Hypothesis: a short recent training window adapts to the target year's regime and transfers the edge.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-adaptive-2y" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2024-01-07"
-                    fit_start_time: "2020-08-31"
-                    fit_end_time: "2022-08-31"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2020-08-31", fit_end_time: "2022-08-31" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2020-08-31", fit_end_time: "2022-08-31" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2020-08-31", "2022-08-31"]
-                valid: ["2022-09-01", "2022-12-30"]
-                test:  ["2023-01-03", "2023-12-29"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2023-01-03"
-                      end_time: "2023-12-29"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-adaptive/m2-sharpe22_2y_2024.yaml

@@ -1,96 +0,0 @@
-# Adaptive short-window retrain: m2-sharpe22 / test 2024 (trace exp 55) — 2y training window
-# Hypothesis: a short recent training window adapts to the target year's regime and transfers the edge.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-adaptive-2y" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2025-01-07"
-                    fit_start_time: "2021-08-31"
-                    fit_end_time: "2023-08-31"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2021-08-31", fit_end_time: "2023-08-31" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2021-08-31", fit_end_time: "2023-08-31" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2021-08-31", "2023-08-31"]
-                valid: ["2023-09-01", "2023-12-29"]
-                test:  ["2024-01-02", "2024-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2024-01-02"
-                      end_time: "2024-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-adaptive/m2-sharpe22_2y_2025.yaml

@@ -1,96 +0,0 @@
-# Adaptive short-window retrain: m2-sharpe22 / test 2025 (trace exp 55) — 2y training window
-# Hypothesis: a short recent training window adapts to the target year's regime and transfers the edge.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-adaptive-2y" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-01-07"
-                    fit_start_time: "2022-08-31"
-                    fit_end_time: "2024-08-30"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2022-08-31", fit_end_time: "2024-08-30" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2022-08-31", fit_end_time: "2024-08-30" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2022-08-31", "2024-08-30"]
-                valid: ["2024-09-03", "2024-12-31"]
-                test:  ["2025-01-02", "2025-12-31"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2025-01-02"
-                      end_time: "2025-12-31"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/bt-m2-sharpe22-adaptive/m2-sharpe22_2y_2026.yaml

@@ -1,96 +0,0 @@
-# Adaptive short-window retrain: m2-sharpe22 / test 2026 (trace exp 55) — 2y training window
-# Hypothesis: a short recent training window adapts to the target year's regime and transfers the edge.
-{% set LAKE = TAC_LAKE_DIR %}
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs: { lake_root: "{{ LAKE }}", market: US }
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-adaptive-2y" }
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-            parallel: 5
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-08-10"
-                    fit_start_time: "2023-09-01"
-                    fit_end_time: "2025-09-01"
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
-                    infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2023-09-01", fit_end_time: "2025-09-01" } }
-                        - { class: ProcessInf, kwargs: {} }
-                        - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2023-09-01", fit_end_time: "2025-09-01" } }
-                        - { class: Fillna, kwargs: {} }
-            segments:
-                train: ["2023-09-01", "2025-09-01"]
-                valid: ["2025-09-03", "2026-01-03"]
-                test:  ["2026-01-04", "2026-08-10"]
-
-    record:
-        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
-        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
-                  backtest:
-                      start_time: "2026-01-04"
-                      end_time: "2026-08-10"
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/exp14-optstop-v2/a_topk_baseline.yaml

@@ -1,136 +0,0 @@
-# -----------------------------------------------------------------------------
-# EXP 14 - Strategy A (baseline): reference model + TopkDropout.
-#
-# Model = RankICEnsembleLGBModel (5-seed RankIC-early-stopped LGB), the class
-# wired by the tac-rd-rank-ensemble-isolated reference (run 0cea66d9...).
-# Strategy = TopkDropout topk=10 n_drop=2 risk_degree=0.95 (the reference's own
-# recorded backtest strategy), so this run reproduces the reference baseline on
-# the same 50-ETF SP-5d panel.
-#
-# Run:
-#   rd_run_workflow config_path=experiments/workflows/exp14-optstop-v2/a_topk_baseline.yaml \
-#       experiment_name=tac-rd-optstop-v2
-# -----------------------------------------------------------------------------
-{%- set LAKE = TAC_LAKE_DIR %}
-{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
-{%- set SP_FIELDS = "sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
-
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs:
-            lake_root: "{{ LAKE }}"
-            market: US
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs:
-            lake_root: "{{ LAKE }}"
-            market: US
-            markets: {}
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs:
-            lake_root: "{{ LAKE }}"
-            market: US
-
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs:
-            uri: "sqlite:///{{ LAKE }}/mlruns.db"
-            default_exp_name: "tac-rd-optstop-v2"
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "{{ UNIVERSE }}"
-                    start_time: 2015-01-03
-                    end_time: 2026-08-14
-                    fit_start_time: 2016-01-04
-                    fit_end_time: 2025-09-01
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,{{ SP_FIELDS }}"
-                    infer_processors:
-                        - class: DropAllNaN
-                          kwargs: {}
-                        - class: ProcessInf
-                          kwargs: {}
-                        - class: CSRankNorm
-                          kwargs: {}
-                        - class: ZScoreNorm
-                          kwargs: {}
-                        - class: Fillna
-                          kwargs: {}
-            segments:
-                train: [2016-01-04, 2025-09-01]
-                valid: [2025-09-03, 2026-01-03]
-                test: [2026-01-04, 2026-08-10]
-
-    record:
-        - class: SignalRecord
-          module_path: qlib.workflow.record_temp
-          kwargs: {}
-        - class: SigAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              ana_long_short: true
-              ann_scaler: 252
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: TopkDropoutStrategy
-                      module_path: qlib.contrib.strategy
-                      kwargs:
-                          signal: "<PRED>"
-                          topk: 10
-                          n_drop: 2
-                          only_tradable: true
-                          risk_degree: 0.95
-                  backtest:
-                      start_time: 2026-01-04
-                      end_time: 2026-08-10
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "{{ UNIVERSE }}"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/exp14-optstop-v2/b_optstop_v2.yaml

@@ -1,149 +0,0 @@
-# -----------------------------------------------------------------------------
-# EXP 14 - Strategy B (enhanced): reference model + OptimalStopControlV2.
-#
-# Model = RankICEnsembleLGBModel (5-seed RankIC-early-stopped LGB), identical to
-# Strategy A. Strategy = OptimalStopControlV2 (tac_qlib.contrib.strategy.
-# optimal_stop_v2) with the controls that address OptimalStopControl's documented
-# weaknesses:
-#   - turnover / cost control: rebalance_band=0.05 (skip small rebalances),
-#     cooldown_days=3 (no whipsaw re-entries), max_turnover=0.30 (cap daily
-#     traded notional, priority exits > opens > rebalances)
-#   - robust thresholds (no valid-window overfit): entry 0.85 / exit 0.70 /
-#     max_hold 10 / min_hold 2 / sl -0.08
-# Sizing = equal-weight control (risk_degree fraction of total value split
-# across targets) - the "proper allocation" that replaces cash-heuristic sizing.
-#
-# Run:
-#   rd_run_workflow config_path=experiments/workflows/exp14-optstop-v2/b_optstop_v2.yaml \
-#       experiment_name=tac-rd-optstop-v2
-# -----------------------------------------------------------------------------
-{%- set LAKE = TAC_LAKE_DIR %}
-{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
-{%- set SP_FIELDS = "sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
-
-qlib_init:
-    provider_uri: "{{ LAKE }}"
-    region: us
-    expression_cache: null
-    dataset_cache: null
-
-    calendar_provider:
-        class: tac_qlib.data.providers.LakeCalendarProvider
-        kwargs:
-            lake_root: "{{ LAKE }}"
-            market: US
-    instrument_provider:
-        class: tac_qlib.data.providers.LakeInstrumentProvider
-        kwargs:
-            lake_root: "{{ LAKE }}"
-            market: US
-            markets: {}
-    feature_provider:
-        class: tac_qlib.data.providers.LakeFeatureProvider
-        kwargs:
-            lake_root: "{{ LAKE }}"
-            market: US
-
-    exp_manager:
-        class: MLflowExpManager
-        module_path: qlib.workflow.expm
-        kwargs:
-            uri: "sqlite:///{{ LAKE }}/mlruns.db"
-            default_exp_name: "tac-rd-optstop-v2"
-
-task:
-    model:
-        class: RankICEnsembleLGBModel
-        module_path: tac_qlib.contrib.model.rank_ensemble
-        kwargs:
-            loss: mse
-            learning_rate: 0.02
-            num_leaves: 31
-            n_estimators: 3000
-            num_boost_round: 3000
-            early_stopping_rounds: 200
-            min_data_in_leaf: 20
-            lambda_l2: 0.5
-            colsample_bytree: 0.8
-            subsample: 0.8
-            subsample_freq: 1
-            reg_alpha: 0.1
-            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
-
-    dataset:
-        class: DatasetH
-        module_path: qlib.data.dataset
-        kwargs:
-            handler:
-                class: TACHandler
-                module_path: tac_qlib.contrib.data.handler
-                kwargs:
-                    instruments: "{{ UNIVERSE }}"
-                    start_time: 2015-01-03
-                    end_time: 2026-08-14
-                    fit_start_time: 2016-01-04
-                    fit_end_time: 2025-09-01
-                    freq: day
-                    lake_root: "{{ LAKE }}"
-                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,{{ SP_FIELDS }}"
-                    infer_processors:
-                        - class: DropAllNaN
-                          kwargs: {}
-                        - class: ProcessInf
-                          kwargs: {}
-                        - class: CSRankNorm
-                          kwargs: {}
-                        - class: ZScoreNorm
-                          kwargs: {}
-                        - class: Fillna
-                          kwargs: {}
-            segments:
-                train: [2016-01-04, 2025-09-01]
-                valid: [2025-09-03, 2026-01-03]
-                test: [2026-01-04, 2026-08-10]
-
-    record:
-        - class: SignalRecord
-          module_path: qlib.workflow.record_temp
-          kwargs: {}
-        - class: SigAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              ana_long_short: true
-              ann_scaler: 252
-        - class: PortAnaRecord
-          module_path: qlib.workflow.record_temp
-          kwargs:
-              config:
-                  strategy:
-                      class: OptimalStopControlV2
-                      module_path: tac_qlib.contrib.strategy.optimal_stop_v2
-                      kwargs:
-                          signal: "<PRED>"
-                          topk: 10
-                          entry_pct: 0.85
-                          exit_pct: 0.70
-                          max_hold_days: 10
-                          min_hold_days: 2
-                          sl: -0.08
-                          risk_degree: 0.95
-                          notional: 20000
-                          rebalance_band: 0.05
-                          cooldown_days: 3
-                          max_turnover: 0.30
-                  backtest:
-                      start_time: 2026-01-04
-                      end_time: 2026-08-10
-                      account: 1000000
-                      benchmark: SPY
-                      exchange_kwargs:
-                          codes: "{{ UNIVERSE }}"
-                          deal_price: $close
-                          freq: day
-                          open_cost: 0.0005
-                          close_cost: 0.0015
-                          min_cost: 5.0
-              risk_analysis_freq: 1d

workflows/exp22/workflow.yaml

@@ -1,6 +1,8 @@
-# Walk-forward: m2-sharpe22 / test 2026 (trace exp 53, ref exp32 c7c12228 on cleaned lake)
-# Strategy TopkDropoutStrategy n_drop=1, parallel=5. Window matches reference exp32 exactly.
-{% set LAKE = TAC_LAKE_DIR %}
+# Re-run of experiment 16 with validated family=ta and family=sp lake features.
+{%- set LAKE = TAC_LAKE_DIR %}
+{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
+{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sma_5,sma_20,ema_12,ema_26,rsi_14,macd,macd_signal,macd_hist,bb_upper,bb_middle,bb_lower,atr_14,adx_14,sp_ret,sp_ou_half_life,sp_ou_revert,sp_ou_zscore,sp_hmm_p_regime1,sp_hmm_state,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_down,sp_max_move,sp_max_up,sp_rv1,sp_rv5,sp_rv22,sp_rv_ac1,sp_rv_cv_22,sp_vol_ratio_1_22,sp_vol_ratio_5_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_1,sp_dsv_5,sp_dsv_22,sp_dsv_ratio_1,sp_dsv_ratio_5,sp_dsv_ratio_22,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sig_level2_lead_lag_5,sp_sig_level2_lag_lead_5" %}
+
 qlib_init:
     provider_uri: "{{ LAKE }}"
     region: us
@@ -18,7 +20,7 @@ qlib_init:
     exp_manager:
         class: MLflowExpManager
         module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-m2-sharpe22-3windows" }
+        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-exp16-db-ta-sp" }
 
 task:
     model:
@@ -39,7 +41,6 @@ task:
             reg_alpha: 0.1
             reg_lambda: 1.0
             seeds: "42,7,2026,99,123"
-            parallel: 5
 
     dataset:
         class: DatasetH
@@ -49,16 +50,16 @@ task:
                 class: TACHandler
                 module_path: tac_qlib.contrib.data.handler
                 kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-08-10"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2025-09-01"
+                    instruments: "{{ UNIVERSE }}"
+                    start_time: 2015-01-03
+                    end_time: 2026-08-10
+                    fit_start_time: 2016-01-04
+                    fit_end_time: 2025-09-01
                     freq: day
                     lake_root: "{{ LAKE }}"
                     market: US
                     label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22"
+                    feature_fields: "{{ FEATURES }}"
                     infer_processors:
                         - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                         - { class: ProcessInf, kwargs: {} }
@@ -66,9 +67,9 @@ task:
                         - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                         - { class: Fillna, kwargs: {} }
             segments:
-                train: ["2016-01-04", "2025-09-01"]
-                valid: ["2025-09-03", "2026-01-03"]
-                test:  ["2026-01-04", "2026-08-10"]
+                train: [2016-01-04, 2025-09-01]
+                valid: [2025-09-03, 2026-01-03]
+                test: [2026-01-04, 2026-08-10]
 
     record:
         - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
@@ -80,14 +81,14 @@ task:
                   strategy:
                       class: TopkDropoutStrategy
                       module_path: qlib.contrib.strategy
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
+                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 2, only_tradable: true, risk_degree: 0.95 }
                   backtest:
-                      start_time: "2026-01-04"
-                      end_time: "2026-08-10"
+                      start_time: 2026-01-04
+                      end_time: 2026-08-10
                       account: 1000000
                       benchmark: SPY
                       exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
+                          codes: "{{ UNIVERSE }}"
                           deal_price: $close
                           freq: day
                           open_cost: 0.0005

workflows/exp23/workflow.yaml

@@ -1,6 +1,8 @@
-# Walk-forward: C-ndrop2 / test 2024
-# 3x3 re-validation (trace exp 52). Strategy TopkDropoutStrategy n_drop=2, parallel=5.
-{% set LAKE = TAC_LAKE_DIR %}
+# General stochastic-process feature ablation: no TA, HMM, or OU fields.
+{%- set LAKE = TAC_LAKE_DIR %}
+{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
+{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_down,sp_max_move,sp_max_up,sp_rv1,sp_rv5,sp_rv22,sp_rv_ac1,sp_rv_cv_22,sp_vol_ratio_1_22,sp_vol_ratio_5_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_1,sp_dsv_5,sp_dsv_22,sp_dsv_ratio_1,sp_dsv_ratio_5,sp_dsv_ratio_22,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sig_level2_lead_lag_5,sp_sig_level2_lag_lead_5" %}
+
 qlib_init:
     provider_uri: "{{ LAKE }}"
     region: us
@@ -18,7 +20,7 @@ qlib_init:
     exp_manager:
         class: MLflowExpManager
         module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-3x3-windows" }
+        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-exp22-stochastic-general" }
 
 task:
     model:
@@ -39,7 +41,7 @@ task:
             reg_alpha: 0.1
             reg_lambda: 1.0
             seeds: "42,7,2026,99,123"
-            parallel: 5
+
     dataset:
         class: DatasetH
         module_path: qlib.data.dataset
@@ -48,26 +50,26 @@ task:
                 class: TACHandler
                 module_path: tac_qlib.contrib.data.handler
                 kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2025-01-07"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2023-08-31"
+                    instruments: "{{ UNIVERSE }}"
+                    start_time: 2015-01-03
+                    end_time: 2026-08-10
+                    fit_start_time: 2016-01-04
+                    fit_end_time: 2025-09-01
                     freq: day
                     lake_root: "{{ LAKE }}"
                     market: US
                     label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead"
+                    feature_fields: "{{ FEATURES }}"
                     infer_processors:
-                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2023-08-31" } }
+                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                         - { class: ProcessInf, kwargs: {} }
                         - { class: CSRankNorm, kwargs: {} }
-                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2023-08-31" } }
+                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                         - { class: Fillna, kwargs: {} }
             segments:
-                train: ["2016-01-04", "2023-08-31"]
-                valid: ["2023-09-01", "2023-12-29"]
-                test:  ["2024-01-02", "2024-12-31"]
+                train: [2016-01-04, 2025-09-01]
+                valid: [2025-09-03, 2026-01-03]
+                test: [2026-01-04, 2026-08-10]
 
     record:
         - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
@@ -81,12 +83,12 @@ task:
                       module_path: qlib.contrib.strategy
                       kwargs: { signal: "<PRED>", topk: 10, n_drop: 2, only_tradable: true, risk_degree: 0.95 }
                   backtest:
-                      start_time: "2024-01-02"
-                      end_time: "2024-12-31"
+                      start_time: 2026-01-04
+                      end_time: 2026-08-10
                       account: 1000000
                       benchmark: SPY
                       exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
+                          codes: "{{ UNIVERSE }}"
                           deal_price: $close
                           freq: day
                           open_cost: 0.0005

workflows/exp24/workflow.yaml

@@ -1,6 +1,8 @@
-# Walk-forward: C-ndrop2 / test 2026
-# 3x3 re-validation (trace exp 52). Strategy TopkDropoutStrategy n_drop=2, parallel=5.
-{% set LAKE = TAC_LAKE_DIR %}
+# Exact compact stochastic feature set requested for a new run in MLflow exp 25.
+{%- set LAKE = TAC_LAKE_DIR %}
+{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
+{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
+
 qlib_init:
     provider_uri: "{{ LAKE }}"
     region: us
@@ -18,7 +20,7 @@ qlib_init:
     exp_manager:
         class: MLflowExpManager
         module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-3x3-windows" }
+        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-exp22-stochastic-general" }
 
 task:
     model:
@@ -39,7 +41,7 @@ task:
             reg_alpha: 0.1
             reg_lambda: 1.0
             seeds: "42,7,2026,99,123"
-            parallel: 5
+
     dataset:
         class: DatasetH
         module_path: qlib.data.dataset
@@ -48,16 +50,16 @@ task:
                 class: TACHandler
                 module_path: tac_qlib.contrib.data.handler
                 kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-08-19"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2025-09-01"
+                    instruments: "{{ UNIVERSE }}"
+                    start_time: 2015-01-03
+                    end_time: 2026-08-10
+                    fit_start_time: 2016-01-04
+                    fit_end_time: 2025-09-01
                     freq: day
                     lake_root: "{{ LAKE }}"
                     market: US
                     label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead"
+                    feature_fields: "{{ FEATURES }}"
                     infer_processors:
                         - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                         - { class: ProcessInf, kwargs: {} }
@@ -65,9 +67,9 @@ task:
                         - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                         - { class: Fillna, kwargs: {} }
             segments:
-                train: ["2016-01-04", "2025-09-01"]
-                valid: ["2025-09-03", "2026-01-03"]
-                test:  ["2026-01-04", "2026-08-19"]
+                train: [2016-01-04, 2025-09-01]
+                valid: [2025-09-03, 2026-01-03]
+                test: [2026-01-04, 2026-08-10]
 
     record:
         - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
@@ -81,12 +83,12 @@ task:
                       module_path: qlib.contrib.strategy
                       kwargs: { signal: "<PRED>", topk: 10, n_drop: 2, only_tradable: true, risk_degree: 0.95 }
                   backtest:
-                      start_time: "2026-01-04"
-                      end_time: "2026-08-19"
+                      start_time: 2026-01-04
+                      end_time: 2026-08-10
                       account: 1000000
                       benchmark: SPY
                       exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
+                          codes: "{{ UNIVERSE }}"
                           deal_price: $close
                           freq: day
                           open_cost: 0.0005

workflows/exp26/workflow.yaml

@@ -1,6 +1,9 @@
-# Walk-forward: B-moments / test 2026
-# 3x3 re-validation (trace exp 52). Strategy TopkDropoutStrategy n_drop=1, parallel=default(auto).
-{% set LAKE = TAC_LAKE_DIR %}
+# Compact stochastic feature set with reduced turnover: n_drop=1 instead of 2.
+# Same setup as exp24 (compact baseline) but replacing the TopkDropout n_drop 2 with 1.
+{%- set LAKE = TAC_LAKE_DIR %}
+{%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
+{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
+
 qlib_init:
     provider_uri: "{{ LAKE }}"
     region: us
@@ -18,7 +21,7 @@ qlib_init:
     exp_manager:
         class: MLflowExpManager
         module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-bt-3x3-windows" }
+        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-exp22-stochastic-general" }
 
 task:
     model:
@@ -48,16 +51,16 @@ task:
                 class: TACHandler
                 module_path: tac_qlib.contrib.data.handler
                 kwargs:
-                    instruments: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
-                    start_time: "2015-01-03"
-                    end_time: "2026-08-19"
-                    fit_start_time: "2016-01-04"
-                    fit_end_time: "2025-09-01"
+                    instruments: "{{ UNIVERSE }}"
+                    start_time: 2015-01-03
+                    end_time: 2026-08-10
+                    fit_start_time: 2016-01-04
+                    fit_end_time: 2025-09-01
                     freq: day
                     lake_root: "{{ LAKE }}"
                     market: US
                     label: "Ref($close,-6)/Ref($close,-1)-1"
-                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_5,sp_dsv_22"
+                    feature_fields: "{{ FEATURES }}"
                     infer_processors:
                         - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                         - { class: ProcessInf, kwargs: {} }
@@ -65,9 +68,9 @@ task:
                         - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                         - { class: Fillna, kwargs: {} }
             segments:
-                train: ["2016-01-04", "2025-09-01"]
-                valid: ["2025-09-03", "2026-01-03"]
-                test:  ["2026-01-04", "2026-08-19"]
+                train: [2016-01-04, 2025-09-01]
+                valid: [2025-09-03, 2026-01-03]
+                test: [2026-01-04, 2026-08-10]
 
     record:
         - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
@@ -81,12 +84,12 @@ task:
                       module_path: qlib.contrib.strategy
                       kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
                   backtest:
-                      start_time: "2026-01-04"
-                      end_time: "2026-08-19"
+                      start_time: 2026-01-04
+                      end_time: 2026-08-10
                       account: 1000000
                       benchmark: SPY
                       exchange_kwargs:
-                          codes: "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM"
+                          codes: "{{ UNIVERSE }}"
                           deal_price: $close
                           freq: day
                           open_cost: 0.0005