refactor(training): 重构股票池管理 API 并更新训练流程

- 移除 StockFilterConfig/MarketCapSelectorConfig，改用 StockPoolManager + filter_func
- Trainer 支持 train/val/test 三分法划分
- 更新 regression.ipynb 适配新 API
- 删除已弃用的 test_selectors.py，后续补充 StockPoolManager 测试

src/training/__init__.py

@@ -17,11 +17,8 @@ from src.training.registry import (
 # 数据划分器
 from src.training.components.splitters import DateSplitter
 
-# 股票池选择器配置
-from src.training.components.selectors import (
-    MarketCapSelectorConfig,
-    StockFilterConfig,
-)
+# 股票池选择器配置（已迁移到 StockPoolManager，保留文件占位）
+# from src.training.components.selectors import ...
 
 # 数据处理器
 from src.training.components.processors import (
@@ -54,9 +51,9 @@ __all__ = [
     "register_processor",
     # 数据划分器
     "DateSplitter",
-    # 股票池选择器配置
-    "StockFilterConfig",
-    "MarketCapSelectorConfig",
+    # 股票池选择器配置（已迁移，保留注释占位）
+    # "StockFilterConfig",  # 已删除，使用 StockPoolManager + filter_func 替代
+    # "MarketCapSelectorConfig",  # 已删除，使用 StockPoolManager + required_factors 替代
     # 数据处理器
     "NullFiller",
     "StandardScaler",

src/training/components/__init__.py

@@ -9,11 +9,8 @@ from src.training.components.base import BaseModel, BaseProcessor
 # 数据划分器
 from src.training.components.splitters import DateSplitter
 
-# 股票池选择器配置
-from src.training.components.selectors import (
-    MarketCapSelectorConfig,
-    StockFilterConfig,
-)
+# 股票池选择器配置（已迁移到 StockPoolManager）
+# from src.training.components.selectors import ...  # 已删除
 
 # 数据处理器
 from src.training.components.processors import (
@@ -29,8 +26,8 @@ __all__ = [
     "BaseModel",
     "BaseProcessor",
     "DateSplitter",
-    "StockFilterConfig",
-    "MarketCapSelectorConfig",
+    # "StockFilterConfig",  # 已删除
+    # "MarketCapSelectorConfig",  # 已删除
     "StandardScaler",
     "CrossSectionalStandardScaler",
     "Winsorizer",

src/training/components/selectors.py

@@ -1,81 +1,20 @@
 """股票池选择器配置
 
-提供股票过滤和市值选择的配置类。
+此模块目前为空，股票池筛选功能已迁移到 StockPoolManager。
+所有筛选逻辑通过传入自定义函数实现。
 """
 
-from dataclasses import dataclass
-from typing import List, Optional
-
-
-@dataclass
-class StockFilterConfig:
-    """股票过滤器配置
-
-    用于过滤掉不需要的股票（如创业板、科创板等）。
-    基于股票代码进行过滤，不依赖外部数据。
-
-    Attributes:
-        exclude_cyb: 是否排除创业板（300xxx, 301xxx）
-        exclude_kcb: 是否排除科创板（688xxx）
-        exclude_bj: 是否排除北交所（.BJ 后缀）
-        exclude_st: 是否排除ST股票（需要外部数据支持）
-    """
-
-    exclude_cyb: bool = True
-    exclude_kcb: bool = True
-    exclude_bj: bool = True
-    exclude_st: bool = True
-
-    def filter_codes(self, codes: List[str]) -> List[str]:
-        """应用过滤条件，返回过滤后的股票代码列表
-
-        Args:
-            codes: 原始股票代码列表
-
-        Returns:
-            过滤后的股票代码列表
-
-        Note:
-            ST 股票过滤需要额外数据，在 StockPoolManager 中处理。
-            此方法仅基于代码前缀进行过滤。
-        """
-        result = []
-        for code in codes:
-            # 排除创业板（300xxx, 301xxx）
-            if self.exclude_cyb and code.startswith(("300", "301")):
-                continue
-            # 排除科创板（688xxx）
-            if self.exclude_kcb and code.startswith("688"):
-                continue
-            # 排除北交所（.BJ 后缀）
-            if self.exclude_bj and code.endswith(".BJ"):
-                continue
-            result.append(code)
-        return result
-
-
-@dataclass
-class MarketCapSelectorConfig:
-    """市值选择器配置
-
-    每日独立选择市值最大或最小的 n 只股票。
-    市值数据从 daily_basic 表独立获取，仅用于筛选。
-
-    Attributes:
-        enabled: 是否启用选择
-        n: 选择前 n 只
-        ascending: False=最大市值, True=最小市值
-        market_cap_col: 市值列名（来自 daily_basic）
-    """
-
-    enabled: bool = True
-    n: int = 100
-    ascending: bool = False
-    market_cap_col: str = "total_mv"
-
-    def __post_init__(self):
-        """验证配置参数"""
-        if self.n <= 0:
-            raise ValueError(f"n 必须是正整数，得到: {self.n}")
-        if not self.market_cap_col:
-            raise ValueError("market_cap_col 不能为空")
+# 旧配置类已删除：
+# - StockFilterConfig (使用 filter_func 替代)
+# - MarketCapSelectorConfig (使用 filter_func + required_factors 替代)
+#
+# 新的使用方式：
+# from src.training import StockPoolManager
+#
+# def my_filter(df: pl.DataFrame) -> pl.Series:
+#     return df["total_mv"] > 1e9
+#
+# pool_manager = StockPoolManager(
+#     filter_func=my_filter,
+#     required_columns=["total_mv"],
+# )

src/training/config/__init__.py

@@ -4,15 +4,13 @@
 """
 
 from src.training.config.config import (
-    MarketCapSelectorConfig,
     ProcessorConfig,
-    StockFilterConfig,
     TrainingConfig,
 )
 
 __all__ = [
     "TrainingConfig",
-    "StockFilterConfig",
-    "MarketCapSelectorConfig",
+    # "StockFilterConfig",  # 已删除
+    # "MarketCapSelectorConfig",  # 已删除
     "ProcessorConfig",
 ]

src/training/config/config.py

@@ -10,26 +10,6 @@ from pydantic import Field, validator
 from pydantic_settings import BaseSettings
 
 
-@dataclass
-class StockFilterConfig:
-    """股票过滤器配置"""
-
-    exclude_cyb: bool = True  # 排除创业板
-    exclude_kcb: bool = True  # 排除科创板
-    exclude_bj: bool = True  # 排除北交所
-    exclude_st: bool = True  # 排除ST股票
-
-
-@dataclass
-class MarketCapSelectorConfig:
-    """市值选择器配置"""
-
-    enabled: bool = True  # 是否启用
-    n: int = 100  # 选择前 n 只
-    ascending: bool = False  # False=最大市值, True=最小市值
-    market_cap_col: str = "total_mv"  # 市值列名（来自 daily_basic）
-
-
 @dataclass
 class ProcessorConfig:
     """处理器配置"""
@@ -56,25 +36,6 @@ class TrainingConfig(BaseSettings):
     test_start: str = Field(..., description="测试期开始 YYYYMMDD")
     test_end: str = Field(..., description="测试期结束 YYYYMMDD")
 
-    # === 股票池配置 ===
-    stock_filter: StockFilterConfig = Field(
-        default_factory=lambda: StockFilterConfig(
-            exclude_cyb=True,
-            exclude_kcb=True,
-            exclude_bj=True,
-            exclude_st=True,
-        )
-    )
-    stock_selector: Optional[MarketCapSelectorConfig] = Field(
-        default_factory=lambda: MarketCapSelectorConfig(
-            enabled=True,
-            n=100,
-            ascending=False,
-            market_cap_col="total_mv",
-        )
-    )
-    # 注意：如果 stock_selector = None，则跳过市值选择
-
     # === 模型配置 ===
     model_type: str = "lightgbm"
     model_params: Dict[str, Any] = Field(default_factory=dict)

src/training/core/stock_pool_manager.py

@@ -1,57 +1,63 @@
 """股票池管理器
 
-每日独立筛选股票池，市值数据从 daily_basic 表独立获取。
+支持使用自定义函数和因子表达式进行每日股票池筛选。
+临时计算的因子仅在筛选阶段使用，绝不泄露到训练数据。
 """
 
-from typing import TYPE_CHECKING, Dict, List, Optional
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Set, Tuple
 
 import polars as pl
 
-from src.training.components.selectors import MarketCapSelectorConfig, StockFilterConfig
-
 if TYPE_CHECKING:
     from src.factors.engine.data_router import DataRouter
 
 
 class StockPoolManager:
-    """股票池管理器 - 每日独立筛选
+    """股票池管理器 - 支持自定义筛选函数和因子
 
-    重要约束：
-    1. 市值数据仅从 daily_basic 表获取，仅用于筛选
-    2. 市值数据绝不混入特征矩阵
-    3. 每日独立筛选（市值是动态变化的）
+    核心特性：
+    1. 支持传入自定义筛选函数
+    2. 支持使用因子表达式进行筛选
+    3. 使用 FactorEngine 计算所需因子
+    4. 只删除本次新生成的临时因子，保留输入中已存在的所有列
 
-    处理流程（每日）：
-        当日所有股票
+    数据流：
+        输入数据 (含原始列，可能包含一些因子)
             ↓
-        代码过滤（创业板、ST等）
+        [准备数据]
+            ├─ 获取缺失的基础列 (from data_router)
+            └─ 计算缺失的因子 (使用 FactorEngine，标记为"本次生成")
             ↓
-        查询 daily_basic 获取当日市值
+        [每日筛选]
+            ├─ group_by("trade_date").apply(filter_func)
+            └─ 只保留 ts_code + trade_date (筛选结果标识)
             ↓
-        市值选择（前N只）
-            ↓
-        返回当日选中股票列表
+        [返回结果]
+            └─ semi join 原始数据，保留所有原始列
     """
 
     def __init__(
         self,
-        filter_config: StockFilterConfig,
-        selector_config: Optional[MarketCapSelectorConfig],
-        data_router: "DataRouter",
+        filter_func: Callable[[pl.DataFrame], pl.Series],
+        required_columns: Optional[List[str]] = None,
+        required_factors: Optional[Dict[str, str]] = None,
+        data_router: Optional["DataRouter"] = None,
         code_col: str = "ts_code",
         date_col: str = "trade_date",
     ):
         """初始化股票池管理器
 
         Args:
-            filter_config: 股票过滤器配置
-            selector_config: 市值选择器配置，None 表示跳过市值选择
-            data_router: 数据路由器，用于获取 daily_basic 数据
+            filter_func: 筛选函数，接收 DataFrame 返回布尔 Series
+            required_columns: 除输入数据外还需获取的基础列
+            required_factors: 筛选所需的因子表达式 {因子名: DSL表达式}
+            data_router: 数据路由器，用于获取缺失列
             code_col: 股票代码列名
             date_col: 日期列名
         """
-        self.filter_config = filter_config
-        self.selector_config = selector_config
+        self.filter_func = filter_func
+        self.required_columns = required_columns or []
+        self.required_factors = required_factors or {}
         self.data_router = data_router
         self.code_col = code_col
         self.date_col = date_col
@@ -59,113 +65,191 @@ class StockPoolManager:
     def filter_and_select_daily(self, data: pl.DataFrame) -> pl.DataFrame:
         """每日独立筛选股票池
 
+        流程：
+        1. 记录输入数据的原始列
+        2. 收集筛选所需的完整数据（基础列 + 计算因子）
+        3. 按日期分组应用筛选函数
+        4. 只返回 ts_code 和 trade_date（筛选结果标识）
+        5. 用标识列从原始数据筛选（保留所有原始列）
+
+        关键：返回的数据包含输入数据的所有原始列，只移除本次新生成的临时因子
+
         Args:
             data: 因子计算后的全市场数据，必须包含 trade_date 和 ts_code 列
 
         Returns:
-            筛选后的数据，仅包含每日选中的股票
-
-        Note:
-            - 按日期分组处理
-            - 市值数据从 daily_basic 独立获取
-            - 保持市值数据与特征数据隔离
+            筛选后的数据，列与输入数据完全一致（临时因子已移除）
         """
-        dates = data.select(self.date_col).unique().sort(self.date_col)
+        # 1. 记录原始列，用于最后验证
+        original_columns = list(data.columns)
 
-        result_frames = []
-        for date in dates.to_series():
-            # 获取当日数据
-            daily_data = data.filter(pl.col(self.date_col) == date)
-            daily_codes = daily_data.select(self.code_col).to_series().to_list()
+        # 2. 准备完整数据（用于筛选判断）
+        # 返回的 enriched 包含临时因子，但不修改原始 data
+        enriched = self._prepare_data(data)
 
-            # 1. 代码过滤
-            filtered_codes = self.filter_config.filter_codes(daily_codes)
-
-            # 2. 市值选择（如果启用）
-            if self.selector_config and self.selector_config.enabled:
-                # 从 daily_basic 获取当日市值
-                market_caps = self._get_market_caps_for_date(filtered_codes, date)
-                selected_codes = self._select_by_market_cap(filtered_codes, market_caps)
-            else:
-                selected_codes = filtered_codes
-
-            # 3. 保留当日选中的股票数据
-            daily_selected = daily_data.filter(
-                pl.col(self.code_col).is_in(selected_codes)
+        # 3. 每日筛选，只保留标识列
+        # 使用 group_by + map_groups 替代 apply（Polars 0.20+）
+        selected_ids = enriched.group_by(self.date_col).map_groups(
+            lambda df: df.filter(self.filter_func(df)).select(
+                [self.code_col, self.date_col]
             )
-            result_frames.append(daily_selected)
-
-        return pl.concat(result_frames)
-
-    def _get_market_caps_for_date(
-        self, codes: List[str], date: str
-    ) -> Dict[str, float]:
-        """从 daily_basic 表获取指定日期的市值数据
-
-        Args:
-            codes: 股票代码列表
-            date: 日期 "YYYYMMDD"
-
-        Returns:
-            {股票代码: 市值} 的字典
-        """
-        if not codes:
-            return {}
-
-        assert self.selector_config is not None, (
-            "selector_config should not be None when calling _get_market_caps_for_date"
         )
 
+        # 4. 用 semi join 从原始数据筛选，自动只保留原始列
+        # semi join: 保留左侧（data）的所有列，只保留匹配的行
+        result = data.join(
+            selected_ids,
+            on=[self.code_col, self.date_col],
+            how="semi",
+        )
+
+        # 5. 验证：确保结果列与原始列完全一致
+        if list(result.columns) != original_columns:
+            raise RuntimeError(
+                f"列发生变化！\n原始: {original_columns}\n结果: {list(result.columns)}"
+            )
+
+        return result
+
+    def _prepare_data(self, data: pl.DataFrame) -> pl.DataFrame:
+        """准备筛选所需的完整数据
+
+        步骤：
+        1. 获取缺失的基础列
+        2. 计算缺失的因子（输入中已存在的因子不再计算）
+
+        Args:
+            data: 输入数据
+
+        Returns:
+            包含所有所需列和因子的数据（含临时因子）
+        """
+        result = data
+
+        # 1. 获取缺失的基础列
+        if self.required_columns and self.data_router is not None:
+            result = self._fetch_required_columns(result)
+
+        # 2. 计算因子（只计算输入中不存在的）
+        if self.required_factors:
+            result = self._compute_factors(result)
+
+        return result
+
+    def _fetch_required_columns(self, data: pl.DataFrame) -> pl.DataFrame:
+        """从 data_router 获取缺失的基础列
+
+        Args:
+            data: 当前数据
+
+        Returns:
+            补充了缺失列的数据
+        """
+        missing_cols = set(self.required_columns) - set(data.columns)
+        if not missing_cols:
+            return data
+
+        if self.data_router is None:
+            raise ValueError(f"需要获取列 {missing_cols}，但未提供 data_router")
+
+        # 获取日期范围
+        dates = data.select(self.date_col).unique().to_series().to_list()
+        if not dates:
+            return data
+
+        start_date = min(dates)
+        end_date = max(dates)
+
+        # 获取所有股票代码
+        codes = data.select(self.code_col).unique().to_series().to_list()
+
         try:
-            # 通过 data_router 查询 daily_basic 表
             from src.factors.engine.data_spec import DataSpec
 
+            # 构建 DataSpec 列表
             data_specs = [
-                DataSpec("daily_basic", [self.selector_config.market_cap_col])
+                DataSpec("daily", list(missing_cols))  # 假设从 daily 表获取
             ]
-            df = self.data_router.fetch_data(
+
+            # 从 data_router 获取数据
+            extra_data = self.data_router.fetch_data(
                 data_specs=data_specs,
-                start_date=date,
-                end_date=date,
+                start_date=start_date,
+                end_date=end_date,
                 stock_codes=codes,
             )
 
-            # 转换为字典
-            market_caps = {}
-            for row in df.iter_rows(named=True):
-                code = row[self.code_col]
-                cap = row.get(self.selector_config.market_cap_col)
-                if cap is not None and code in codes:
-                    market_caps[code] = float(cap)
+            # 合并到结果
+            result = data.join(
+                extra_data,
+                on=[self.code_col, self.date_col],
+                how="left",
+            )
 
-            return market_caps
+            return result
 
         except Exception as e:
-            print(f"[警告] 获取 {date} 市值数据失败: {e}")
-            return {}
+            print(f"[警告] 获取缺失列失败: {e}")
+            # 如果获取失败，继续使用现有数据（筛选可能不完全）
+            return data
 
-    def _select_by_market_cap(
-        self, codes: List[str], market_caps: Dict[str, float]
-    ) -> List[str]:
-        """根据市值选择股票
+    def _compute_factors(self, data: pl.DataFrame) -> pl.DataFrame:
+        """使用 FactorEngine 计算筛选所需的因子
+
+        只计算输入数据中不存在的因子，已存在的因子直接使用。
 
         Args:
-            codes: 股票代码列表
-            market_caps: 市值数据字典
+            data: 当前数据
 
         Returns:
-            选中的股票代码列表
+            补充了缺失因子的数据（含临时因子）
         """
-        if self.selector_config is None:
-            return codes
+        existing_cols = set(data.columns)
 
-        if not market_caps:
-            return codes[: self.selector_config.n]
+        # 确定需要计算的因子（输入中不存在的）
+        factors_to_compute = {
+            name: expr
+            for name, expr in self.required_factors.items()
+            if name not in existing_cols
+        }
 
-        # 按市值排序并选择前N只
-        sorted_codes = sorted(
-            codes,
-            key=lambda c: market_caps.get(c, 0),
-            reverse=not self.selector_config.ascending,
-        )
-        return sorted_codes[: self.selector_config.n]
+        if not factors_to_compute:
+            # 所有因子都已存在，无需计算
+            return data
+
+        try:
+            from src.factors import FactorEngine
+
+            # 获取日期范围
+            dates = data.select(self.date_col).unique().to_series().to_list()
+            if not dates:
+                return data
+
+            start_date = min(dates)
+            end_date = max(dates)
+
+            # 创建 FactorEngine 并注册因子
+            engine = FactorEngine()
+            for name, expr in factors_to_compute.items():
+                engine.add_factor(name, expr)
+
+            # 计算因子
+            factor_data = engine.compute(
+                factor_names=list(factors_to_compute.keys()),
+                start_date=start_date,
+                end_date=end_date,
+            )
+
+            # 合并到数据（左连接，保留所有原始行）
+            result = data.join(
+                factor_data,
+                on=[self.code_col, self.date_col],
+                how="left",
+            )
+
+            return result
+
+        except Exception as e:
+            print(f"[警告] 计算因子失败: {e}")
+            # 如果计算失败，继续使用现有数据
+            return data

src/training/core/trainer.py

@@ -97,13 +97,14 @@ class Trainer:
             print("[筛选] 每日独立筛选股票池...")
             data = self.pool_manager.filter_and_select_daily(data)
 
-        # 2. 划分训练/测试集
+        # 2. 划分训练/验证/测试集（三分法）
         if self.splitter:
-            print("[划分] 划分训练集和测试集...")
-            train_data, test_data = self.splitter.split(data)
+            print("[划分] 划分训练集、验证集和测试集...")
+            train_data, val_data, test_data = self.splitter.split(data)
         else:
             # 没有划分器，全部作为训练集
             train_data = data
+            val_data = data
             test_data = data
 
         # 3. 训练集：processors fit_transform