refactor(strategy): 取消数据不足标的剔除逻辑，保留所有标的以暴露策略问题

- compute_factors: 不剔除数据不足/缺失率高的标的
- 改为警告并保留，因子值NaN时信号生成自动跳过
- 目的：暴露策略自身问题，后续支持更多大类资产
- 回测配置改为start_date=2000-01-01以测试更长历史

strategies/rotation/config.yaml

@@ -68,7 +68,7 @@ benchmark:
   name: "沪深300"
 
 # ==================== 回测参数 ====================
-start_date: "2019-01-01"
+start_date: "2000-01-01"
 
 # ==================== 因子参数 ====================
 # 动量/趋势窗口期（天数）

strategies/rotation/strategy.py

@@ -277,7 +277,10 @@ class RotationStrategy(StrategyBase):
         }
     
     def compute_factors(self, data: dict) -> pd.DataFrame:
-        """计算因子值（匹配原引擎：先计算因子再对齐到A股交易日历）"""
+        """计算因子值（匹配原引擎：先计算因子再对齐到A股交易日历）
+        
+        注意：不剔除数据不足的标的，保留所有标的以暴露策略问题
+        """
         index_data = data['index_data']
         valid_codes = data['valid_codes']
         
@@ -299,18 +302,14 @@ class RotationStrategy(StrategyBase):
         for code in valid_codes:
             df = index_data[code].copy()
             
-            # 原引擎剔除逻辑：如果有OHLCV列，整行dropna()后再检查长度
+            # 检查是否有OHLCV数据
-            # 这会剔除国债等只有close数据的标的（open/high/low全空）
             ohlcv_cols = ['open', 'high', 'low', 'close', 'volume']
             has_ohlcv = all(col in df.columns for col in ['open', 'high', 'low', 'close'])
             
             if has_ohlcv:
-                # 原引擎逻辑：整行dropna()后检查数据是否足够
+                # 如果有完整OHLCV，整行dropna()后提取close
                 df_clean = df[ohlcv_cols].dropna()
-                if len(df_clean) < self.n_days + 1:
+                close_series = df_clean['close'] if len(df_clean) > 0 else pd.Series(dtype=float)
-                    print(f"  ⚠ 剔除 {code}: OHLCV数据不足 ({len(df_clean)} < {self.n_days + 1})")
-                    continue
-                close_series = df_clean['close']
             else:
                 # 只有close列的情况
                 if 'close' in df.columns:
@@ -318,34 +317,37 @@ class RotationStrategy(StrategyBase):
                 else:
                     close_series = df.dropna()
             
-                if len(close_series) < self.n_days + 1:
+            # 检查数据长度并警告，但不剔除
-                    print(f"  ⚠ 剔除 {code}: close数据不足 ({len(close_series)} < {self.n_days + 1})")
+            if len(close_series) < self.n_days + 1:
-                    continue
+                print(f"  ⚠ {code}: 数据不足 ({len(close_series)} < {self.n_days + 1})，保留但因子值可能为NaN")
             
             # 原引擎逻辑：先在原始交易日历上计算因子
             # rolling窗口使用的是原始交易日数据，不包含ffill填充的重复值
-            close_df = pd.DataFrame({'close': close_series})
+            if len(close_series) > 0:
-            factor_series = self._factor.compute(close_df)
+                close_df = pd.DataFrame({'close': close_series})
+                factor_series = self._factor.compute(close_df)
                 
-            # 然后对齐因子序列到A股交易日历（匹配原引擎逻辑）
+                # 然后对齐因子序列到A股交易日历（匹配原引擎逻辑）
-            factor_aligned = factor_series.reindex(a_share_dates, method='ffill')
+                factor_aligned = factor_series.reindex(a_share_dates, method='ffill')
+            else:
+                # 没有数据，创建空的因子序列
+                factor_aligned = pd.Series(index=a_share_dates, dtype=float)
             
             factor_values[code] = factor_aligned
             final_valid_codes.append(code)
         
         factor_df = pd.DataFrame(factor_values)
         
-        # 过滤缺失率过高的标的
+        # 检查缺失率并警告，但不剔除（保留所有标的以暴露策略问题）
         total_rows = len(factor_df)
         for code in final_valid_codes:
             if code in factor_df.columns:
                 null_pct = factor_df[code].isnull().sum() / total_rows
                 if null_pct > 0.5:
-                    print(f"  ⚠ 剔除 {code}: 缺失率 {null_pct:.1%} 过高")
+                    print(f"  ⚠ {code}: 缺失率 {null_pct:.1%} 较高，保留但信号生成时可能跳过")
-                    factor_df = factor_df.drop(columns=[code])
         
-        # 更新有效代码列表
+        # 不更新有效代码列表，保留所有原始代码
-        data['valid_codes'] = [c for c in final_valid_codes if c in factor_df.columns]
+        data['valid_codes'] = final_valid_codes
         
         return factor_df