ProStock/src/experiment/regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 导入依赖"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:07:39.837396Z",
     "start_time": "2026-03-08T15:07:39.834964Z"
    }
   },
   "source": [
    "import os\n",
    "from datetime import datetime\n",
    "from typing import List\n",
    "\n",
    "import polars as pl\n",
    "\n",
    "from src.factors import FactorEngine\n",
    "from src.training import (\n",
    "    DateSplitter,\n",
    "    LightGBMModel,\n",
    "    STFilter,\n",
    "    StandardScaler,\n",
    "    StockFilterConfig,\n",
    "    StockPoolManager,\n",
    "    Trainer,\n",
    "    Winsorizer,\n",
    "    NullFiller,\n",
    ")\n",
    "from src.training.config import TrainingConfig"
   ],
   "outputs": [],
   "execution_count": 19
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 定义辅助函数"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:07:39.849909Z",
     "start_time": "2026-03-08T15:07:39.843845Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def create_factors_with_strings(engine: FactorEngine, factor_definitions: dict, label_factor: dict) -> List[str]:\n",
    "    print(\"=\" * 80)\n",
    "    print(\"使用字符串表达式定义因子\")\n",
    "    print(\"=\" * 80)\n",
    "\n",
    "    # 注册所有特征因子\n",
    "    print(\"\\n注册特征因子:\")\n",
    "    for name, expr in factor_definitions.items():\n",
    "        engine.add_factor(name, expr)\n",
    "        print(f\"  - {name}: {expr}\")\n",
    "\n",
    "    # 注册 label 因子\n",
    "    print(\"\\n注册 Label 因子:\")\n",
    "    for name, expr in label_factor.items():\n",
    "        engine.add_factor(name, expr)\n",
    "        print(f\"  - {name}: {expr}\")\n",
    "\n",
    "    # 从字典自动获取特征列\n",
    "    feature_cols = list(factor_definitions.keys())\n",
    "\n",
    "    print(f\"\\n特征因子数: {len(feature_cols)}\")\n",
    "    print(f\"Label: {list(label_factor.keys())[0]}\")\n",
    "    print(f\"已注册因子总数: {len(engine.list_registered())}\")\n",
    "\n",
    "    return feature_cols\n",
    "\n",
    "\n",
    "def prepare_data(\n",
    "    engine: FactorEngine,\n",
    "    feature_cols: List[str],\n",
    "    start_date: str,\n",
    "    end_date: str,\n",
    ") -> pl.DataFrame:\n",
    "    print(\"\\n\" + \"=\" * 80)\n",
    "    print(\"准备数据\")\n",
    "    print(\"=\" * 80)\n",
    "\n",
    "    # 计算因子（全市场数据）\n",
    "    print(f\"\\n计算因子: {start_date} - {end_date}\")\n",
    "    factor_names = feature_cols + [LABEL_NAME]  # 包含 label\n",
    "\n",
    "    data = engine.compute(\n",
    "        factor_names=factor_names,\n",
    "        start_date=start_date,\n",
    "        end_date=end_date,\n",
    "    )\n",
    "\n",
    "    print(f\"数据形状: {data.shape}\")\n",
    "    print(f\"数据列: {data.columns}\")\n",
    "    print(f\"\\n前5行预览:\")\n",
    "    print(data.head())\n",
    "\n",
    "    return data"
   ],
   "outputs": [],
   "execution_count": 20
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 配置参数\n",
    "\n",
    "### 3.1 因子定义"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:07:39.857927Z",
     "start_time": "2026-03-08T15:07:39.853639Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 特征因子定义字典：新增因子只需在此处添加一行\n",
    "LABEL_NAME = 'future_return_5'\n",
    "\n",
    "FACTOR_DEFINITIONS = {\n",
    "    # ================= 1. 价格与趋势因子 (Trend & Momentum) =================\n",
    "    \"ma_5\": \"ts_mean(close, 5)\",\n",
    "    \"ma_20\": \"ts_mean(close, 20)\",\n",
    "    \"ma_ratio_5_20\": \"ts_mean(close, 5) / (ts_mean(close, 20) + 1e-8) - 1\",  # 均线发散度\n",
    "    \"bias_10\": \"close / (ts_mean(close, 10) + 1e-8) - 1\",  # 10日乖离率(反转/动量)\n",
    "    \"high_low_ratio\": \"(close - ts_min(low, 20)) / (ts_max(high, 20) - ts_min(low, 20) + 1e-8)\",  # 价格在近20日的位置(威廉指标变形)\n",
    "    \"bbi_ratio\": \"(ts_mean(close, 3) + ts_mean(close, 6) + ts_mean(close, 12) + ts_mean(close, 24)) / (4 * close + 1e-8)\",  # BBI 多空指标比率\n",
    "\n",
    "    # ================= 2. 收益率与波动率因子 (Return & Volatility) =================\n",
    "    \"return_5\": \"(close / ts_delay(close, 5)) - 1\",  # 5日动量/反转\n",
    "    \"return_10\": \"(close / ts_delay(close, 10)) - 1\",\n",
    "    \"return_20\": \"(close / ts_delay(close, 20)) - 1\",\n",
    "    \"return_diff_5_10\": \"(close / ts_delay(close, 5)) - (close / ts_delay(close, 10))\",  # 收益率加速/减速趋势\n",
    "    \"volatility_5\": \"ts_std(close, 5)\",\n",
    "    \"volatility_20\": \"ts_std(close, 20)\",\n",
    "    \"volatility_ratio\": \"ts_std(close, 5) / (ts_std(close, 20) + 1e-8)\",  # 波动率期限结构（近期是否剧烈震荡）\n",
    "    \"std_return_5\": \"ts_std((close / ts_delay(close, 1)) - 1, 5)\",  # 5日真实收益率波动率\n",
    "    \"std_return_20\": \"ts_std((close / ts_delay(close, 1)) - 1, 20)\", # 20日真实收益率波动率\n",
    "\n",
    "    # ================= 3. 量能与流动性因子 (Volume & Liquidity) =================\n",
    "    \"volume_ratio_5_20\": \"ts_mean(vol, 5) / (ts_mean(vol, 20) + 1e-8)\",  # 相对放量指标\n",
    "    \"volume_change_rate\": \"ts_mean(vol, 2) / (ts_mean(vol, 10) + 1e-8) - 1\",  # 短期成交量异动\n",
    "    \"turnover_rate_mean_5\": \"ts_mean(turnover_rate, 5)\",  # 5日平均换手率（活跃度）\n",
    "    \"turnover_rate_std_20\": \"ts_std(turnover_rate, 20)\",  # 换手率波动率（炒作情绪稳定性）\n",
    "    \"turnover_deviation\": \"(turnover_rate - ts_mean(turnover_rate, 10)) / (ts_std(turnover_rate, 10) + 1e-8)\",  # 换手率偏离度\n",
    "    # \"amihud_illiq_20\": \"ts_mean(abs((close / ts_delay(close, 1)) - 1) / (amount + 1e-8), 20)\",  # Amihud非流动性指标(核心Alpha)\n",
    "\n",
    "    # ================= 4. 截面排名因子 (Cross-Sectional Rank) =================\n",
    "    \"market_cap_rank\": \"cs_rank(total_mv)\",  # 市值规模排名（Size因子）\n",
    "    \"turnover_rank\": \"cs_rank(turnover_rate)\",  # 当日换手率全市场排名\n",
    "    \"return_5_rank\": \"cs_rank((close / ts_delay(close, 5)) - 1)\",  # 5日收益率截面排名（横向比价）\n",
    "\n",
    "    # # ================= 5. 财务质量因子 (Quality) =================\n",
    "    # # 注：底层数据引擎需确保 n_income 等字段已就绪，或者映射到 fina_indicator\n",
    "    # \"roe\": \"n_income / (total_hldr_eqy_exc_min_int + 1e-8)\",  # ROE 净资产收益率 (盈利效率)\n",
    "    # \"roa\": \"n_income / (total_assets + 1e-8)\",  # ROA 总资产收益率\n",
    "    # \"profit_margin\": \"n_income / (revenue + 1e-8)\",  # 销售净利率 (定价权)\n",
    "    # \"debt_to_asset\": \"total_liab / (total_assets + 1e-8)\",  # 资产负债率 (杠杆/破产风险)\n",
    "    # \"cash_to_liab\": \"money_cap / (total_liab + 1e-8)\",  # 现金流负债比 (流动性风险)\n",
    "    #\n",
    "    # # ================= 6. 财务估值因子 (Value / Yield) =================\n",
    "    # # 注：经典量化不用 PE (Price/Earn)，而是用 EP (Earn/Price)，因为亏损公司的 PE 是负的或无穷大，EP 可以平滑处理。\n",
    "    # \"EP\": \"n_income / (total_mv * 10000 + 1e-8)\",  # 盈利收益率 (Earnings Yield, 相当于 1/PE) *注:Tushare市值需乘10000对齐单位\n",
    "    # \"BP\": \"total_hldr_eqy_exc_min_int / (total_mv * 10000 + 1e-8)\",  # 账面市值比 (Book to Price, 相当于 1/PB)\n",
    "    # \"CP\": \"n_cashflow_act / (total_mv * 10000 + 1e-8)\",  # 现金流收益率 (Cashflow Yield)\n",
    "    # \"SP\": \"revenue / (total_mv * 10000 + 1e-8)\",  # 销售收益率 (Sales to Price, 相当于 1/PS)\n",
    "    #\n",
    "    # # 估值截面排名 (直接提取全市场最便宜、最赚钱的公司)\n",
    "    # \"EP_rank\": \"cs_rank(n_income / (total_mv + 1e-8))\",\n",
    "    # \"BP_rank\": \"cs_rank(total_hldr_eqy_exc_min_int / (total_mv + 1e-8))\",\n",
    "}\n",
    "\n",
    "# Label 因子定义（不参与训练，用于计算目标）\n",
    "LABEL_FACTOR = {\n",
    "    LABEL_NAME: \"(ts_delay(close, -5) / close) - 1\",  # 未来5日收益率\n",
    "}"
   ],
   "outputs": [],
   "execution_count": 21
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 训练参数配置"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:07:39.865371Z",
     "start_time": "2026-03-08T15:07:39.861138Z"
    }
   },
   "source": [
    "# 日期范围配置（正确的 train/val/test 三分法）\n",
    "# Train: 用于训练模型参数\n",
    "# Val: 用于验证/早停/调参（位于 train 之后，test 之前）\n",
    "# Test: 仅用于最终评估，完全独立于训练过程\n",
    "TRAIN_START = \"20200101\"\n",
    "TRAIN_END = \"20231231\"\n",
    "VAL_START = \"20240101\"\n",
    "VAL_END = \"20241231\"\n",
    "TEST_START = \"20250101\"\n",
    "TEST_END = \"20251231\"\n",
    "\n",
    "# 模型参数配置\n",
    "MODEL_PARAMS = {\n",
    "    \"objective\": \"regression\",\n",
    "    \"metric\": \"mae\",  # 改为 MAE，对异常值更稳健\n",
    "    # 树结构控制（防过拟合核心）\n",
    "    \"num_leaves\": 20,  # 从31降为20，降低模型复杂度\n",
    "    \"max_depth\": 4,  # 显式限制深度，防止过度拟合噪声\n",
    "    \"min_child_samples\": 50,  # 叶子最小样本数，防止学习极端样本\n",
    "    \"min_child_weight\": 0.001,\n",
    "    # 学习参数\n",
    "    \"learning_rate\": 0.01,  # 降低学习率，配合更多树\n",
    "    \"n_estimators\": 1000,  # 增加树数量，配合早停\n",
    "    # 采样策略（关键防过拟合）\n",
    "    \"subsample\": 0.8,  # 每棵树随机采样80%数据（行采样）\n",
    "    \"subsample_freq\": 5,  # 每5轮迭代进行一次 subsample\n",
    "    \"colsample_bytree\": 0.8,  # 每棵树随机选择80%特征（列采样）\n",
    "    # 正则化\n",
    "    \"reg_alpha\": 0.1,  # L1正则，增加稀疏性\n",
    "    \"reg_lambda\": 1.0,  # L2正则，平滑权重\n",
    "    # 数值稳定性\n",
    "    \"verbose\": -1,\n",
    "    \"random_state\": 42,\n",
    "}\n",
    "\n",
    "# 数据处理器配置\n",
    "PROCESSOR_CONFIGS = [\n",
    "    {\"name\": \"winsorizer\", \"params\": {\"lower\": 0.01, \"upper\": 0.99}},\n",
    "    {\"name\": \"cs_standard_scaler\", \"params\": {}},\n",
    "]\n",
    "\n",
    "# 股票池筛选配置\n",
    "STOCK_FILTER_CONFIG = {\n",
    "    \"exclude_cyb\": True,  # 排除创业板\n",
    "    \"exclude_kcb\": True,  # 排除科创板\n",
    "    \"exclude_bj\": True,  # 排除北交所\n",
    "    \"exclude_st\": True,  # 排除ST股票\n",
    "}\n",
    "\n",
    "# 输出配置（相对于本文件所在目录）\n",
    "OUTPUT_DIR = \"output\"\n",
    "SAVE_PREDICTIONS = True\n",
    "PERSIST_MODEL = False\n",
    "\n",
    "# Top N 配置：每日推荐股票数量\n",
    "TOP_N = 5  # 可调整为 10, 20 等"
   ],
   "outputs": [],
   "execution_count": 22
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 训练流程\n",
    "\n",
    "### 4.1 初始化组件"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:07:47.887413Z",
     "start_time": "2026-03-08T15:07:39.874187Z"
    }
   },
   "source": [
    "print(\"\\n\" + \"=\" * 80)\n",
    "print(\"LightGBM 回归模型训练\")\n",
    "print(\"=\" * 80)\n",
    "\n",
    "# 1. 创建 FactorEngine\n",
    "print(\"\\n[1] 创建 FactorEngine\")\n",
    "engine = FactorEngine()\n",
    "\n",
    "# 2. 使用字符串表达式定义因子\n",
    "print(\"\\n[2] 定义因子（字符串表达式）\")\n",
    "feature_cols = create_factors_with_strings(engine, FACTOR_DEFINITIONS, LABEL_FACTOR)\n",
    "target_col = LABEL_NAME\n",
    "\n",
    "# 3. 准备数据（使用模块级别的日期配置）\n",
    "print(\"\\n[3] 准备数据\")\n",
    "\n",
    "data = prepare_data(\n",
    "    engine=engine,\n",
    "    feature_cols=feature_cols,\n",
    "    start_date=TRAIN_START,\n",
    "    end_date=TEST_END,\n",
    ")\n",
    "\n",
    "# 4. 打印配置信息\n",
    "print(f\"\\n[配置] 训练期: {TRAIN_START} - {TRAIN_END}\")\n",
    "print(f\"[配置] 验证期: {VAL_START} - {VAL_END}\")\n",
    "print(f\"[配置] 测试期: {TEST_START} - {TEST_END}\")\n",
    "print(f\"[配置] 特征数: {len(feature_cols)}\")\n",
    "print(f\"[配置] 目标变量: {target_col}\")\n",
    "\n",
    "# 5. 创建模型\n",
    "model = LightGBMModel(params=MODEL_PARAMS)\n",
    "\n",
    "# 6. 创建数据处理器\n",
    "processors = [\n",
    "    NullFiller(strategy=\"mean\"),\n",
    "    Winsorizer(**PROCESSOR_CONFIGS[0][\"params\"]),\n",
    "    StandardScaler(exclude_cols=[\"ts_code\", \"trade_date\", target_col]),\n",
    "]\n",
    "\n",
    "# 7. 创建数据划分器（正确的 train/val/test 三分法）\n",
    "# Train: 训练模型参数 | Val: 验证/早停 | Test: 最终评估\n",
    "splitter = DateSplitter(\n",
    "    train_start=TRAIN_START,\n",
    "    train_end=TRAIN_END,\n",
    "    val_start=VAL_START,\n",
    "    val_end=VAL_END,\n",
    "    test_start=TEST_START,\n",
    "    test_end=TEST_END,\n",
    ")\n",
    "\n",
    "# 8. 创建股票池管理器\n",
    "pool_manager = StockPoolManager(\n",
    "    filter_config=StockFilterConfig(**STOCK_FILTER_CONFIG),\n",
    "    selector_config=None,  # 暂时不启用市值选择\n",
    "    data_router=engine.router,\n",
    ")\n",
    "\n",
    "# 9. 创建 ST 股票过滤器\n",
    "st_filter = STFilter(\n",
    "    data_router=engine.router,\n",
    ")\n",
    "\n",
    "# 10. 创建训练器\n",
    "trainer = Trainer(\n",
    "    model=model,\n",
    "    pool_manager=pool_manager,\n",
    "    processors=processors,\n",
    "    filters=[st_filter],\n",
    "    splitter=splitter,\n",
    "    target_col=target_col,\n",
    "    feature_cols=feature_cols,\n",
    "    persist_model=PERSIST_MODEL,\n",
    ")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "LightGBM 回归模型训练\n",
      "================================================================================\n",
      "\n",
      "[1] 创建 FactorEngine\n",
      "\n",
      "[2] 定义因子（字符串表达式）\n",
      "================================================================================\n",
      "使用字符串表达式定义因子\n",
      "================================================================================\n",
      "\n",
      "注册特征因子:\n",
      "  - ma_5: ts_mean(close, 5)\n",
      "  - ma_20: ts_mean(close, 20)\n",
      "  - ma_ratio_5_20: ts_mean(close, 5) / (ts_mean(close, 20) + 1e-8) - 1\n",
      "  - bias_10: close / (ts_mean(close, 10) + 1e-8) - 1\n",
      "  - high_low_ratio: (close - ts_min(low, 20)) / (ts_max(high, 20) - ts_min(low, 20) + 1e-8)\n",
      "  - bbi_ratio: (ts_mean(close, 3) + ts_mean(close, 6) + ts_mean(close, 12) + ts_mean(close, 24)) / (4 * close + 1e-8)\n",
      "  - return_5: (close / ts_delay(close, 5)) - 1\n",
      "  - return_10: (close / ts_delay(close, 10)) - 1\n",
      "  - return_20: (close / ts_delay(close, 20)) - 1\n",
      "  - return_diff_5_10: (close / ts_delay(close, 5)) - (close / ts_delay(close, 10))\n",
      "  - volatility_5: ts_std(close, 5)\n",
      "  - volatility_20: ts_std(close, 20)\n",
      "  - volatility_ratio: ts_std(close, 5) / (ts_std(close, 20) + 1e-8)\n",
      "  - std_return_5: ts_std((close / ts_delay(close, 1)) - 1, 5)\n",
      "  - std_return_20: ts_std((close / ts_delay(close, 1)) - 1, 20)\n",
      "  - volume_ratio_5_20: ts_mean(vol, 5) / (ts_mean(vol, 20) + 1e-8)\n",
      "  - volume_change_rate: ts_mean(vol, 2) / (ts_mean(vol, 10) + 1e-8) - 1\n",
      "  - turnover_rate_mean_5: ts_mean(turnover_rate, 5)\n",
      "  - turnover_rate_std_20: ts_std(turnover_rate, 20)\n",
      "  - turnover_deviation: (turnover_rate - ts_mean(turnover_rate, 10)) / (ts_std(turnover_rate, 10) + 1e-8)\n",
      "  - market_cap_rank: cs_rank(total_mv)\n",
      "  - turnover_rank: cs_rank(turnover_rate)\n",
      "  - return_5_rank: cs_rank((close / ts_delay(close, 5)) - 1)\n",
      "\n",
      "注册 Label 因子:\n",
      "  - future_return_5: (ts_delay(close, -5) / close) - 1\n",
      "\n",
      "特征因子数: 23\n",
      "Label: future_return_5\n",
      "已注册因子总数: 24\n",
      "\n",
      "[3] 准备数据\n",
      "\n",
      "================================================================================\n",
      "准备数据\n",
      "================================================================================\n",
      "\n",
      "计算因子: 20200101 - 20251231\n",
      "数据形状: (7044952, 32)\n",
      "数据列: ['ts_code', 'trade_date', 'high', 'close', 'low', 'vol', 'turnover_rate', 'total_mv', 'ma_5', 'ma_20', 'ma_ratio_5_20', 'bias_10', 'high_low_ratio', 'bbi_ratio', 'return_5', 'return_10', 'return_20', 'return_diff_5_10', 'volatility_5', 'volatility_20', 'volatility_ratio', 'std_return_5', 'std_return_20', 'volume_ratio_5_20', 'volume_change_rate', 'turnover_rate_mean_5', 'turnover_rate_std_20', 'turnover_deviation', 'market_cap_rank', 'turnover_rank', 'return_5_rank', 'future_return_5']\n",
      "\n",
      "前5行预览:\n",
      "shape: (5, 32)\n",
      "┌───────────┬────────────┬───────┬───────┬───┬─────────────┬─────────────┬────────────┬────────────┐\n",
      "│ ts_code   ┆ trade_date ┆ high  ┆ close ┆ … ┆ market_cap_ ┆ turnover_ra ┆ return_5_r ┆ future_ret │\n",
      "│ ---       ┆ ---        ┆ ---   ┆ ---   ┆   ┆ rank        ┆ nk          ┆ ank        ┆ urn_5      │\n",
      "│ str       ┆ str        ┆ f64   ┆ f64   ┆   ┆ ---         ┆ ---         ┆ ---        ┆ ---        │\n",
      "│           ┆            ┆       ┆       ┆   ┆ f64         ┆ f64         ┆ f64        ┆ f64        │\n",
      "╞═══════════╪════════════╪═══════╪═══════╪═══╪═════════════╪═════════════╪════════════╪════════════╡\n",
      "│ 002082.SZ ┆ 20200102   ┆ 29.23 ┆ 28.24 ┆ … ┆ 0.136631    ┆ 0.728075    ┆ null       ┆ -0.024079  │\n",
      "│ 600387.SH ┆ 20200102   ┆ 24.42 ┆ 24.28 ┆ … ┆ 0.381818    ┆ 0.561497    ┆ null       ┆ 0.058896   │\n",
      "│ 000592.SZ ┆ 20200102   ┆ 18.68 ┆ 18.42 ┆ … ┆ 0.53262     ┆ 0.436898    ┆ null       ┆ 0.128122   │\n",
      "│ 002920.SZ ┆ 20200102   ┆ 31.51 ┆ 31.29 ┆ … ┆ 0.831551    ┆ 0.575668    ┆ null       ┆ 0.129434   │\n",
      "│ 600138.SH ┆ 20200102   ┆ 68.71 ┆ 68.23 ┆ … ┆ 0.702139    ┆ 0.556551    ┆ null       ┆ 0.010992   │\n",
      "└───────────┴────────────┴───────┴───────┴───┴─────────────┴─────────────┴────────────┴────────────┘\n",
      "\n",
      "[配置] 训练期: 20200101 - 20231231\n",
      "[配置] 验证期: 20240101 - 20241231\n",
      "[配置] 测试期: 20250101 - 20251231\n",
      "[配置] 特征数: 23\n",
      "[配置] 目标变量: future_return_5\n"
     ]
    }
   ],
   "execution_count": 23
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 执行训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:07:53.576371Z",
     "start_time": "2026-03-08T15:07:47.898097Z"
    }
   },
   "source": [
    "print(\"\\n\" + \"=\" * 80)\n",
    "print(\"开始训练\")\n",
    "print(\"=\" * 80)\n",
    "\n",
    "# 步骤 1: 股票池筛选\n",
    "print(\"\\n[步骤 1/6] 股票池筛选\")\n",
    "print(\"-\" * 60)\n",
    "if pool_manager:\n",
    "    print(\"  执行每日独立筛选股票池...\")\n",
    "    filtered_data = pool_manager.filter_and_select_daily(data)\n",
    "    print(f\"  筛选前数据规模: {data.shape}\")\n",
    "    print(f\"  筛选后数据规模: {filtered_data.shape}\")\n",
    "    print(f\"  筛选前股票数: {data['ts_code'].n_unique()}\")\n",
    "    print(f\"  筛选后股票数: {filtered_data['ts_code'].n_unique()}\")\n",
    "    print(f\"  删除记录数: {len(data) - len(filtered_data)}\")\n",
    "else:\n",
    "    filtered_data = data\n",
    "    print(\"  未配置股票池管理器，跳过筛选\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "开始训练\n",
      "================================================================================\n",
      "\n",
      "[步骤 1/6] 股票池筛选\n",
      "------------------------------------------------------------\n",
      "  执行每日独立筛选股票池...\n",
      "  筛选前数据规模: (7044952, 32)\n",
      "  筛选后数据规模: (4532198, 32)\n",
      "  筛选前股票数: 5678\n",
      "  筛选后股票数: 3359\n",
      "  删除记录数: 2512754\n"
     ]
    }
   ],
   "execution_count": 24
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:07:54.854708Z",
     "start_time": "2026-03-08T15:07:53.584313Z"
    }
   },
   "source": [
    "# 步骤 2: 划分训练/验证/测试集（正确的三分法）\n",
    "print(\"\\n[步骤 2/6] 划分训练集、验证集和测试集\")\n",
    "print(\"-\" * 60)\n",
    "if splitter:\n",
    "    # 正确的三分法：train用于训练，val用于验证/早停，test仅用于最终评估\n",
    "    train_data, val_data, test_data = splitter.split(filtered_data)\n",
    "    print(f\"  训练集数据规模: {train_data.shape}\")\n",
    "    print(f\"  验证集数据规模: {val_data.shape}\")\n",
    "    print(f\"  测试集数据规模: {test_data.shape}\")\n",
    "    print(f\"  训练集股票数: {train_data['ts_code'].n_unique()}\")\n",
    "    print(f\"  验证集股票数: {val_data['ts_code'].n_unique()}\")\n",
    "    print(f\"  测试集股票数: {test_data['ts_code'].n_unique()}\")\n",
    "    print(\n",
    "        f\"  训练集日期范围: {train_data['trade_date'].min()} - {train_data['trade_date'].max()}\"\n",
    "    )\n",
    "    print(\n",
    "        f\"  验证集日期范围: {val_data['trade_date'].min()} - {val_data['trade_date'].max()}\"\n",
    "    )\n",
    "    print(\n",
    "        f\"  测试集日期范围: {test_data['trade_date'].min()} - {test_data['trade_date'].max()}\"\n",
    "    )\n",
    "\n",
    "    print(\"\\n  训练集前5行预览:\")\n",
    "    print(train_data.head())\n",
    "    print(\"\\n  验证集前5行预览:\")\n",
    "    print(val_data.head())\n",
    "    print(\"\\n  测试集前5行预览:\")\n",
    "    print(test_data.head())\n",
    "else:\n",
    "    train_data = filtered_data\n",
    "    test_data = filtered_data\n",
    "    print(\"  未配置划分器，全部作为训练集\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[步骤 2/6] 划分训练集、验证集和测试集\n",
      "------------------------------------------------------------\n",
      "  训练集数据规模: (2991506, 32)\n",
      "  验证集数据规模: (769485, 32)\n",
      "  测试集数据规模: (771207, 32)\n",
      "  训练集股票数: 3297\n",
      "  验证集股票数: 3220\n",
      "  测试集股票数: 3215\n",
      "  训练集日期范围: 20200102 - 20231229\n",
      "  验证集日期范围: 20240102 - 20241231\n",
      "  测试集日期范围: 20250102 - 20251231\n",
      "\n",
      "  训练集前5行预览:\n",
      "shape: (5, 32)\n",
      "┌───────────┬────────────┬───────┬───────┬───┬─────────────┬─────────────┬────────────┬────────────┐\n",
      "│ ts_code   ┆ trade_date ┆ high  ┆ close ┆ … ┆ market_cap_ ┆ turnover_ra ┆ return_5_r ┆ future_ret │\n",
      "│ ---       ┆ ---        ┆ ---   ┆ ---   ┆   ┆ rank        ┆ nk          ┆ ank        ┆ urn_5      │\n",
      "│ str       ┆ str        ┆ f64   ┆ f64   ┆   ┆ ---         ┆ ---         ┆ ---        ┆ ---        │\n",
      "│           ┆            ┆       ┆       ┆   ┆ f64         ┆ f64         ┆ f64        ┆ f64        │\n",
      "╞═══════════╪════════════╪═══════╪═══════╪═══╪═════════════╪═════════════╪════════════╪════════════╡\n",
      "│ 002082.SZ ┆ 20200102   ┆ 29.23 ┆ 28.24 ┆ … ┆ 0.136631    ┆ 0.728075    ┆ null       ┆ -0.024079  │\n",
      "│ 600387.SH ┆ 20200102   ┆ 24.42 ┆ 24.28 ┆ … ┆ 0.381818    ┆ 0.561497    ┆ null       ┆ 0.058896   │\n",
      "│ 000592.SZ ┆ 20200102   ┆ 18.68 ┆ 18.42 ┆ … ┆ 0.53262     ┆ 0.436898    ┆ null       ┆ 0.128122   │\n",
      "│ 002920.SZ ┆ 20200102   ┆ 31.51 ┆ 31.29 ┆ … ┆ 0.831551    ┆ 0.575668    ┆ null       ┆ 0.129434   │\n",
      "│ 600138.SH ┆ 20200102   ┆ 68.71 ┆ 68.23 ┆ … ┆ 0.702139    ┆ 0.556551    ┆ null       ┆ 0.010992   │\n",
      "└───────────┴────────────┴───────┴───────┴───┴─────────────┴─────────────┴────────────┴────────────┘\n",
      "\n",
      "  验证集前5行预览:\n",
      "shape: (5, 32)\n",
      "┌───────────┬────────────┬───────┬───────┬───┬─────────────┬─────────────┬────────────┬────────────┐\n",
      "│ ts_code   ┆ trade_date ┆ high  ┆ close ┆ … ┆ market_cap_ ┆ turnover_ra ┆ return_5_r ┆ future_ret │\n",
      "│ ---       ┆ ---        ┆ ---   ┆ ---   ┆   ┆ rank        ┆ nk          ┆ ank        ┆ urn_5      │\n",
      "│ str       ┆ str        ┆ f64   ┆ f64   ┆   ┆ ---         ┆ ---         ┆ ---        ┆ ---        │\n",
      "│           ┆            ┆       ┆       ┆   ┆ f64         ┆ f64         ┆ f64        ┆ f64        │\n",
      "╞═══════════╪════════════╪═══════╪═══════╪═══╪═════════════╪═════════════╪════════════╪════════════╡\n",
      "│ 600099.SH ┆ 20240102   ┆ 29.14 ┆ 28.8  ┆ … ┆ 0.097785    ┆ 0.779655    ┆ 0.904941   ┆ -0.039236  │\n",
      "│ 600918.SH ┆ 20240102   ┆ 7.02  ┆ 6.94  ┆ … ┆ 0.951764    ┆ 0.04298     ┆ 0.163254   ┆ -0.027378  │\n",
      "│ 600590.SH ┆ 20240102   ┆ 30.84 ┆ 30.09 ┆ … ┆ 0.532282    ┆ 0.789696    ┆ 0.920534   ┆ -0.072117  │\n",
      "│ 000430.SZ ┆ 20240102   ┆ 30.76 ┆ 30.67 ┆ … ┆ 0.159722    ┆ 0.473724    ┆ 0.77926    ┆ 0.039126   │\n",
      "│ 601881.SH ┆ 20240102   ┆ 13.63 ┆ 13.33 ┆ … ┆ 0.984234    ┆ 0.196134    ┆ 0.139395   ┆ -0.029257  │\n",
      "└───────────┴────────────┴───────┴───────┴───┴─────────────┴─────────────┴────────────┴────────────┘\n",
      "\n",
      "  测试集前5行预览:\n",
      "shape: (5, 32)\n",
      "┌───────────┬────────────┬────────┬────────┬───┬────────────┬────────────┬────────────┬────────────┐\n",
      "│ ts_code   ┆ trade_date ┆ high   ┆ close  ┆ … ┆ market_cap ┆ turnover_r ┆ return_5_r ┆ future_ret │\n",
      "│ ---       ┆ ---        ┆ ---    ┆ ---    ┆   ┆ _rank      ┆ ank        ┆ ank        ┆ urn_5      │\n",
      "│ str       ┆ str        ┆ f64    ┆ f64    ┆   ┆ ---        ┆ ---        ┆ ---        ┆ ---        │\n",
      "│           ┆            ┆        ┆        ┆   ┆ f64        ┆ f64        ┆ f64        ┆ f64        │\n",
      "╞═══════════╪════════════╪════════╪════════╪═══╪════════════╪════════════╪════════════╪════════════╡\n",
      "│ 605507.SH ┆ 20250102   ┆ 22.54  ┆ 21.55  ┆ … ┆ 0.75652    ┆ 0.281669   ┆ 0.449767   ┆ -0.058933  │\n",
      "│ 600993.SH ┆ 20250102   ┆ 322.06 ┆ 312.13 ┆ … ┆ 0.75149    ┆ 0.235469   ┆ 0.626281   ┆ -0.024765  │\n",
      "│ 600817.SH ┆ 20250102   ┆ 57.79  ┆ 55.83  ┆ … ┆ 0.568554   ┆ 0.162072   ┆ 0.442498   ┆ 0.007165   │\n",
      "│ 603896.SH ┆ 20250102   ┆ 29.75  ┆ 28.56  ┆ … ┆ 0.411513   ┆ 0.283718   ┆ 0.504194   ┆ -0.044468  │\n",
      "│ 600754.SH ┆ 20250102   ┆ 87.68  ┆ 85.56  ┆ … ┆ 0.91114    ┆ 0.477273   ┆ 0.825909   ┆ -0.062997  │\n",
      "└───────────┴────────────┴────────┴────────┴───┴────────────┴────────────┴────────────┴────────────┘\n"
     ]
    }
   ],
   "execution_count": 25
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:07:55.786511Z",
     "start_time": "2026-03-08T15:07:54.859705Z"
    }
   },
   "source": [
    "# 步骤 3: 训练集数据处理\n",
    "print(\"\\n[步骤 3/6] 训练集数据处理\")\n",
    "print(\"-\" * 60)\n",
    "fitted_processors = []\n",
    "if processors:\n",
    "    for i, processor in enumerate(processors, 1):\n",
    "        print(\n",
    "            f\"  [{i}/{len(processors)}] 应用处理器: {processor.__class__.__name__}\"\n",
    "        )\n",
    "        train_data_before = len(train_data)\n",
    "        train_data = processor.fit_transform(train_data)\n",
    "        train_data_after = len(train_data)\n",
    "        fitted_processors.append(processor)\n",
    "        print(f\"      处理前记录数: {train_data_before}\")\n",
    "        print(f\"      处理后记录数: {train_data_after}\")\n",
    "        if train_data_before != train_data_after:\n",
    "            print(f\"      删除记录数: {train_data_before - train_data_after}\")\n",
    "\n",
    "print(\"\\n  训练集处理后前5行预览:\")\n",
    "print(train_data.head())\n",
    "print(f\"\\n  训练集特征统计:\")\n",
    "print(f\"    特征数: {len(feature_cols)}\")\n",
    "print(f\"    样本数: {len(train_data)}\")\n",
    "print(f\"    缺失值统计:\")\n",
    "for col in feature_cols[:5]:  # 只显示前5个特征的缺失值\n",
    "    null_count = train_data[col].null_count()\n",
    "    if null_count > 0:\n",
    "        print(\n",
    "            f\"      {col}: {null_count} ({null_count / len(train_data) * 100:.2f}%)\"\n",
    "        )"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[步骤 3/6] 训练集数据处理\n",
      "------------------------------------------------------------\n",
      "  [1/3] 应用处理器: NullFiller\n",
      "      处理前记录数: 2991506\n",
      "      处理后记录数: 2991506\n",
      "  [2/3] 应用处理器: Winsorizer\n",
      "      处理前记录数: 2991506\n",
      "      处理后记录数: 2991506\n",
      "  [3/3] 应用处理器: StandardScaler\n",
      "      处理前记录数: 2991506\n",
      "      处理后记录数: 2991506\n",
      "\n",
      "  训练集处理后前5行预览:\n",
      "shape: (5, 32)\n",
      "┌───────────┬───────────┬───────────┬───────────┬───┬───────────┬───────────┬───────────┬──────────┐\n",
      "│ ts_code   ┆ trade_dat ┆ high      ┆ close     ┆ … ┆ market_ca ┆ turnover_ ┆ return_5_ ┆ future_r │\n",
      "│ ---       ┆ e         ┆ ---       ┆ ---       ┆   ┆ p_rank    ┆ rank      ┆ rank      ┆ eturn_5  │\n",
      "│ str       ┆ ---       ┆ f64       ┆ f64       ┆   ┆ ---       ┆ ---       ┆ ---       ┆ ---      │\n",
      "│           ┆ str       ┆           ┆           ┆   ┆ f64       ┆ f64       ┆ f64       ┆ f64      │\n",
      "╞═══════════╪═══════════╪═══════════╪═══════════╪═══╪═══════════╪═══════════╪═══════════╪══════════╡\n",
      "│ 002082.SZ ┆ 20200102  ┆ -0.303819 ┆ -0.30681  ┆ … ┆ -1.365199 ┆ 1.001092  ┆ null      ┆ -0.02407 │\n",
      "│           ┆           ┆           ┆           ┆   ┆           ┆           ┆           ┆ 9        │\n",
      "│ 600387.SH ┆ 20200102  ┆ -0.334151 ┆ -0.332286 ┆ … ┆ -0.518195 ┆ 0.411746  ┆ null      ┆ 0.058896 │\n",
      "│ 000592.SZ ┆ 20200102  ┆ -0.370349 ┆ -0.369985 ┆ … ┆ 0.002754  ┆ -0.029081 ┆ null      ┆ 0.128122 │\n",
      "│ 002920.SZ ┆ 20200102  ┆ -0.289441 ┆ -0.287188 ┆ … ┆ 1.035415  ┆ 0.461883  ┆ null      ┆ 0.129434 │\n",
      "│ 600138.SH ┆ 20200102  ┆ -0.054852 ┆ -0.04954  ┆ … ┆ 0.58836   ┆ 0.394246  ┆ null      ┆ 0.010992 │\n",
      "└───────────┴───────────┴───────────┴───────────┴───┴───────────┴───────────┴───────────┴──────────┘\n",
      "\n",
      "  训练集特征统计:\n",
      "    特征数: 23\n",
      "    样本数: 2991506\n",
      "    缺失值统计:\n",
      "      ma_5: 11541 (0.39%)\n",
      "      ma_20: 54850 (1.83%)\n",
      "      ma_ratio_5_20: 54850 (1.83%)\n",
      "      bias_10: 25950 (0.87%)\n",
      "      high_low_ratio: 54850 (1.83%)\n"
     ]
    }
   ],
   "execution_count": 26
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:08:10.050651Z",
     "start_time": "2026-03-08T15:07:55.791554Z"
    }
   },
   "source": [
    "# 步骤 4: 训练模型\n",
    "print(\"\\n[步骤 4/6] 训练模型\")\n",
    "print(\"-\" * 60)\n",
    "print(f\"  模型类型: LightGBM\")\n",
    "print(f\"  训练样本数: {len(train_data)}\")\n",
    "print(f\"  特征数: {len(feature_cols)}\")\n",
    "print(f\"  目标变量: {target_col}\")\n",
    "\n",
    "X_train = train_data.select(feature_cols)\n",
    "y_train = train_data.select(target_col).to_series()\n",
    "\n",
    "print(f\"\\n  目标变量统计:\")\n",
    "print(f\"    均值: {y_train.mean():.6f}\")\n",
    "print(f\"    标准差: {y_train.std():.6f}\")\n",
    "print(f\"    最小值: {y_train.min():.6f}\")\n",
    "print(f\"    最大值: {y_train.max():.6f}\")\n",
    "print(f\"    缺失值: {y_train.null_count()}\")\n",
    "\n",
    "print(\"\\n  开始训练...\")\n",
    "model.fit(X_train, y_train)\n",
    "print(\"  训练完成！\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[步骤 4/6] 训练模型\n",
      "------------------------------------------------------------\n",
      "  模型类型: LightGBM\n",
      "  训练样本数: 2991506\n",
      "  特征数: 23\n",
      "  目标变量: future_return_5\n",
      "\n",
      "  目标变量统计:\n",
      "    均值: 0.001610\n",
      "    标准差: 0.059623\n",
      "    最小值: -0.155098\n",
      "    最大值: 0.212842\n",
      "    缺失值: 0\n",
      "\n",
      "  开始训练...\n",
      "  训练完成！\n"
     ]
    }
   ],
   "execution_count": 27
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:08:10.136262Z",
     "start_time": "2026-03-08T15:08:10.055577Z"
    }
   },
   "source": [
    "# 步骤 5: 测试集数据处理\n",
    "print(\"\\n[步骤 5/6] 测试集数据处理\")\n",
    "print(\"-\" * 60)\n",
    "if processors and test_data is not train_data:\n",
    "    for i, processor in enumerate(fitted_processors, 1):\n",
    "        print(\n",
    "            f\"  [{i}/{len(fitted_processors)}] 应用处理器: {processor.__class__.__name__}\"\n",
    "        )\n",
    "        test_data_before = len(test_data)\n",
    "        test_data = processor.transform(test_data)\n",
    "        test_data_after = len(test_data)\n",
    "        print(f\"      处理前记录数: {test_data_before}\")\n",
    "        print(f\"      处理后记录数: {test_data_after}\")\n",
    "else:\n",
    "    print(\"  跳过测试集处理\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[步骤 5/6] 测试集数据处理\n",
      "------------------------------------------------------------\n",
      "  [1/3] 应用处理器: NullFiller\n",
      "      处理前记录数: 771207\n",
      "      处理后记录数: 771207\n",
      "  [2/3] 应用处理器: Winsorizer\n",
      "      处理前记录数: 771207\n",
      "      处理后记录数: 771207\n",
      "  [3/3] 应用处理器: StandardScaler\n",
      "      处理前记录数: 771207\n",
      "      处理后记录数: 771207\n"
     ]
    }
   ],
   "execution_count": 28
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:08:11.299483Z",
     "start_time": "2026-03-08T15:08:10.141988Z"
    }
   },
   "source": [
    "# 步骤 6: 生成预测\n",
    "print(\"\\n[步骤 6/6] 生成预测\")\n",
    "print(\"-\" * 60)\n",
    "X_test = test_data.select(feature_cols)\n",
    "print(f\"  测试样本数: {len(X_test)}\")\n",
    "print(\"  预测中...\")\n",
    "predictions = model.predict(X_test)\n",
    "print(f\"  预测完成！\")\n",
    "\n",
    "print(f\"\\n  预测结果统计:\")\n",
    "print(f\"    均值: {predictions.mean():.6f}\")\n",
    "print(f\"    标准差: {predictions.std():.6f}\")\n",
    "print(f\"    最小值: {predictions.min():.6f}\")\n",
    "print(f\"    最大值: {predictions.max():.6f}\")\n",
    "\n",
    "# 保存结果到 trainer\n",
    "trainer.results = test_data.with_columns([pl.Series(\"prediction\", predictions)])"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[步骤 6/6] 生成预测\n",
      "------------------------------------------------------------\n",
      "  测试样本数: 771207\n",
      "  预测中...\n",
      "  预测完成！\n",
      "\n",
      "  预测结果统计:\n",
      "    均值: 0.000634\n",
      "    标准差: 0.008134\n",
      "    最小值: -0.156166\n",
      "    最大值: 0.131927\n"
     ]
    }
   ],
   "execution_count": 29
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 训练指标曲线"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:08:15.854279Z",
     "start_time": "2026-03-08T15:08:11.304814Z"
    }
   },
   "source": [
    "print(\"\\n\" + \"=\" * 80)\n",
    "print(\"训练指标曲线\")\n",
    "print(\"=\" * 80)\n",
    "\n",
    "# 重新训练以收集指标（因为之前的训练没有保存评估结果）\n",
    "print(\"\\n重新训练模型以收集训练指标...\")\n",
    "\n",
    "import lightgbm as lgb\n",
    "\n",
    "# 准备数据（使用 val 做验证，test 不参与训练过程）\n",
    "X_train_np = X_train.to_numpy()\n",
    "y_train_np = y_train.to_numpy()\n",
    "X_val_np = val_data.select(feature_cols).to_numpy()\n",
    "y_val_np = val_data.select(target_col).to_series().to_numpy()\n",
    "\n",
    "# 创建数据集\n",
    "train_dataset = lgb.Dataset(X_train_np, label=y_train_np)\n",
    "val_dataset = lgb.Dataset(X_val_np, label=y_val_np, reference=train_dataset)\n",
    "\n",
    "# 用于存储评估结果\n",
    "evals_result = {}\n",
    "\n",
    "# 使用与原模型相同的参数重新训练\n",
    "# 正确的三分法：train用于训练，val用于验证，test不参与训练过程\n",
    "# 添加早停：如果验证指标连续100轮没有改善则停止训练\n",
    "booster_with_eval = lgb.train(\n",
    "    MODEL_PARAMS,\n",
    "    train_dataset,\n",
    "    num_boost_round=MODEL_PARAMS.get(\"n_estimators\", 100),\n",
    "    valid_sets=[train_dataset, val_dataset],\n",
    "    valid_names=[\"train\", \"val\"],\n",
    "    callbacks=[\n",
    "        lgb.record_evaluation(evals_result),\n",
    "        lgb.early_stopping(stopping_rounds=100, verbose=True),\n",
    "    ],\n",
    ")\n",
    "\n",
    "print(\"训练完成，指标已收集\")\n",
    "\n",
    "# 获取指标名称\n",
    "metric_name = list(evals_result[\"train\"].keys())[0]\n",
    "print(f\"\\n评估指标: {metric_name}\")\n",
    "\n",
    "# 提取训练和验证指标\n",
    "train_metric = evals_result[\"train\"][metric_name]\n",
    "val_metric = evals_result[\"val\"][metric_name]\n",
    "\n",
    "# 显示早停信息\n",
    "actual_rounds = len(train_metric)\n",
    "expected_rounds = MODEL_PARAMS.get(\"n_estimators\", 100)\n",
    "print(f\"\\n[早停信息]\")\n",
    "print(f\"  配置的最大轮数: {expected_rounds}\")\n",
    "print(f\"  实际训练轮数: {actual_rounds}\")\n",
    "if actual_rounds < expected_rounds:\n",
    "    print(f\"  早停状态: 已触发（连续100轮验证指标未改善）\")\n",
    "else:\n",
    "    print(f\"  早停状态: 未触发（达到最大轮数）\")\n",
    "\n",
    "print(f\"\\n最终指标:\")\n",
    "print(f\"  训练 {metric_name}: {train_metric[-1]:.6f}\")\n",
    "print(f\"  验证 {metric_name}: {val_metric[-1]:.6f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "训练指标曲线\n",
      "================================================================================\n",
      "\n",
      "重新训练模型以收集训练指标...\n",
      "Training until validation scores don't improve for 100 rounds\n",
      "Early stopping, best iteration is:\n",
      "[164]\ttrain's l1: 0.0424587\tval's l1: 0.0537962\n",
      "训练完成，指标已收集\n",
      "\n",
      "评估指标: l1\n",
      "\n",
      "[早停信息]\n",
      "  配置的最大轮数: 1000\n",
      "  实际训练轮数: 264\n",
      "  早停状态: 已触发（连续100轮验证指标未改善）\n",
      "\n",
      "最终指标:\n",
      "  训练 l1: 0.042329\n",
      "  验证 l1: 0.053824\n"
     ]
    }
   ],
   "execution_count": 30
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:08:15.945008Z",
     "start_time": "2026-03-08T15:08:15.859092Z"
    }
   },
   "source": [
    "# 绘制训练指标曲线\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12, 6))\n",
    "\n",
    "# 绘制训练集和验证集的指标曲线（注意：val用于验证，test不参与训练）\n",
    "iterations = range(1, len(train_metric) + 1)\n",
    "ax.plot(iterations, train_metric, label=f\"Train {metric_name}\", linewidth=2, color=\"blue\")\n",
    "ax.plot(iterations, val_metric, label=f\"Validation {metric_name}\", linewidth=2, color=\"red\")\n",
    "\n",
    "ax.set_xlabel(\"Iteration\", fontsize=12)\n",
    "ax.set_ylabel(metric_name.upper(), fontsize=12)\n",
    "ax.set_title(f\"Training and Validation {metric_name.upper()} Curve\", fontsize=14, fontweight=\"bold\")\n",
    "ax.legend(fontsize=10)\n",
    "ax.grid(True, alpha=0.3)\n",
    "\n",
    "# 标记最佳验证指标点（用于早停决策）\n",
    "best_iter = val_metric.index(min(val_metric))\n",
    "best_metric = min(val_metric)\n",
    "ax.axvline(x=best_iter + 1, color=\"green\", linestyle=\"--\", alpha=0.7, label=f\"Best Iteration ({best_iter + 1})\")\n",
    "ax.scatter([best_iter + 1], [best_metric], color=\"green\", s=100, zorder=5)\n",
    "ax.annotate(\n",
    "    f\"Best: {best_metric:.6f}\\nIter: {best_iter + 1}\",\n",
    "    xy=(best_iter + 1, best_metric),\n",
    "    xytext=(best_iter + 1 + len(iterations) * 0.1, best_metric),\n",
    "    fontsize=9,\n",
    "    arrowprops=dict(arrowstyle=\"->\", color=\"green\", alpha=0.7),\n",
    ")\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "print(f\"\\n[指标分析]\")\n",
    "print(f\"  最佳验证 {metric_name}: {best_metric:.6f}\")\n",
    "print(f\"  最佳迭代轮数: {best_iter + 1}\")\n",
    "print(f\"  早停建议: 如果验证指标连续10轮不下降，建议在第 {best_iter + 1} 轮停止训练\")\n",
    "print(f\"\\n[重要提醒] 验证集仅用于早停/调参，测试集完全独立于训练过程！\")"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x600 with 1 Axes>"
      ],
      "image/png": "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
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[指标分析]\n",
      "  最佳验证 l1: 0.053796\n",
      "  最佳迭代轮数: 164\n",
      "  早停建议: 如果验证指标连续10轮不下降，建议在第 164 轮停止训练\n",
      "\n",
      "[重要提醒] 验证集仅用于早停/调参，测试集完全独立于训练过程！\n"
     ]
    }
   ],
   "execution_count": 31
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4 查看结果"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:08:15.963026Z",
     "start_time": "2026-03-08T15:08:15.951854Z"
    }
   },
   "source": [
    "print(\"\\n\" + \"=\" * 80)\n",
    "print(\"训练结果\")\n",
    "print(\"=\" * 80)\n",
    "\n",
    "results = trainer.results\n",
    "\n",
    "print(f\"\\n结果数据形状: {results.shape}\")\n",
    "print(f\"结果列: {results.columns}\")\n",
    "print(f\"\\n结果前10行预览:\")\n",
    "print(results.head(10))\n",
    "print(f\"\\n结果后5行预览:\")\n",
    "print(results.tail())\n",
    "\n",
    "print(f\"\\n每日预测样本数统计:\")\n",
    "daily_counts = results.group_by(\"trade_date\").agg(pl.len()).sort(\"trade_date\")\n",
    "print(f\"  最小: {daily_counts['len'].min()}\")\n",
    "print(f\"  最大: {daily_counts['len'].max()}\")\n",
    "print(f\"  平均: {daily_counts['len'].mean():.2f}\")\n",
    "\n",
    "# 展示某一天的前10个预测结果\n",
    "sample_date = results[\"trade_date\"][0]\n",
    "sample_data = results.filter(results[\"trade_date\"] == sample_date).head(10)\n",
    "print(f\"\\n示例日期 {sample_date} 的前10条预测:\")\n",
    "print(sample_data.select([\"ts_code\", \"trade_date\", target_col, \"prediction\"]))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "训练结果\n",
      "================================================================================\n",
      "\n",
      "结果数据形状: (771207, 33)\n",
      "结果列: ['ts_code', 'trade_date', 'high', 'close', 'low', 'vol', 'turnover_rate', 'total_mv', 'ma_5', 'ma_20', 'ma_ratio_5_20', 'bias_10', 'high_low_ratio', 'bbi_ratio', 'return_5', 'return_10', 'return_20', 'return_diff_5_10', 'volatility_5', 'volatility_20', 'volatility_ratio', 'std_return_5', 'std_return_20', 'volume_ratio_5_20', 'volume_change_rate', 'turnover_rate_mean_5', 'turnover_rate_std_20', 'turnover_deviation', 'market_cap_rank', 'turnover_rank', 'return_5_rank', 'future_return_5', 'prediction']\n",
      "\n",
      "结果前10行预览:\n",
      "shape: (10, 33)\n",
      "┌───────────┬───────────┬───────────┬───────────┬───┬───────────┬───────────┬───────────┬──────────┐\n",
      "│ ts_code   ┆ trade_dat ┆ high      ┆ close     ┆ … ┆ turnover_ ┆ return_5_ ┆ future_re ┆ predicti │\n",
      "│ ---       ┆ e         ┆ ---       ┆ ---       ┆   ┆ rank      ┆ rank      ┆ turn_5    ┆ on       │\n",
      "│ str       ┆ ---       ┆ f64       ┆ f64       ┆   ┆ ---       ┆ ---       ┆ ---       ┆ ---      │\n",
      "│           ┆ str       ┆           ┆           ┆   ┆ f64       ┆ f64       ┆ f64       ┆ f64      │\n",
      "╞═══════════╪═══════════╪═══════════╪═══════════╪═══╪═══════════╪═══════════╪═══════════╪══════════╡\n",
      "│ 605507.SH ┆ 20250102  ┆ -0.346007 ┆ -0.349849 ┆ … ┆ -0.578277 ┆ -0.191441 ┆ -0.058933 ┆ 0.006321 │\n",
      "│ 600993.SH ┆ 20250102  ┆ 1.542811  ┆ 1.519556  ┆ … ┆ -0.74173  ┆ 0.436504  ┆ -0.024765 ┆ 0.002311 │\n",
      "│ 600817.SH ┆ 20250102  ┆ -0.123715 ┆ -0.129313 ┆ … ┆ -1.001409 ┆ -0.217301 ┆ 0.007165  ┆ 0.011855 │\n",
      "│ 603896.SH ┆ 20250102  ┆ -0.300539 ┆ -0.304751 ┆ … ┆ -0.571027 ┆ 0.002181  ┆ -0.044468 ┆ 0.013161 │\n",
      "│ 600754.SH ┆ 20250102  ┆ 0.064776  ┆ 0.06195   ┆ … ┆ 0.113762  ┆ 1.146671  ┆ -0.062997 ┆ -0.00216 │\n",
      "│           ┆           ┆           ┆           ┆   ┆           ┆           ┆           ┆ 3        │\n",
      "│ 603008.SH ┆ 20250102  ┆ -0.311449 ┆ -0.312278 ┆ … ┆ -0.192712 ┆ -0.166907 ┆ -0.018255 ┆ 0.008841 │\n",
      "│ 603650.SH ┆ 20250102  ┆ -0.251099 ┆ -0.263256 ┆ … ┆ -0.405596 ┆ -1.310734 ┆ -0.005427 ┆ 0.008721 │\n",
      "│ 002236.SZ ┆ 20250102  ┆ 4.21561   ┆ 4.130212  ┆ … ┆ 0.279852  ┆ -0.810765 ┆ -0.0513   ┆ 0.007152 │\n",
      "│ 603855.SH ┆ 20250102  ┆ -0.315863 ┆ -0.321092 ┆ … ┆ -0.960546 ┆ 0.258796  ┆ -0.044197 ┆ 0.007929 │\n",
      "│ 002513.SZ ┆ 20250102  ┆ -0.401879 ┆ -0.403117 ┆ … ┆ 1.141935  ┆ -1.044172 ┆ -0.020347 ┆ 0.02149  │\n",
      "└───────────┴───────────┴───────────┴───────────┴───┴───────────┴───────────┴───────────┴──────────┘\n",
      "\n",
      "结果后5行预览:\n",
      "shape: (5, 33)\n",
      "┌───────────┬───────────┬───────────┬───────────┬───┬───────────┬───────────┬───────────┬──────────┐\n",
      "│ ts_code   ┆ trade_dat ┆ high      ┆ close     ┆ … ┆ turnover_ ┆ return_5_ ┆ future_re ┆ predicti │\n",
      "│ ---       ┆ e         ┆ ---       ┆ ---       ┆   ┆ rank      ┆ rank      ┆ turn_5    ┆ on       │\n",
      "│ str       ┆ ---       ┆ f64       ┆ f64       ┆   ┆ ---       ┆ ---       ┆ ---       ┆ ---      │\n",
      "│           ┆ str       ┆           ┆           ┆   ┆ f64       ┆ f64       ┆ f64       ┆ f64      │\n",
      "╞═══════════╪═══════════╪═══════════╪═══════════╪═══╪═══════════╪═══════════╪═══════════╪══════════╡\n",
      "│ 603062.SH ┆ 20251231  ┆ -0.155813 ┆ -0.151122 ┆ … ┆ 0.341316  ┆ 0.721984  ┆ null      ┆ 0.001931 │\n",
      "│ 600543.SH ┆ 20251231  ┆ -0.404843 ┆ -0.404275 ┆ … ┆ 0.52152   ┆ -1.221834 ┆ null      ┆ 0.000149 │\n",
      "│ 601199.SH ┆ 20251231  ┆ -0.312584 ┆ -0.310026 ┆ … ┆ -1.386182 ┆ -0.708964 ┆ null      ┆ -0.00138 │\n",
      "│           ┆           ┆           ┆           ┆   ┆           ┆           ┆           ┆ 7        │\n",
      "│ 600597.SH ┆ 20251231  ┆ -0.351304 ┆ -0.349398 ┆ … ┆ -1.302562 ┆ -0.518432 ┆ null      ┆ -0.00432 │\n",
      "│           ┆           ┆           ┆           ┆   ┆           ┆           ┆           ┆ 7        │\n",
      "│ 600365.SH ┆ 20251231  ┆ -0.433978 ┆ -0.433418 ┆ … ┆ -1.417944 ┆ -1.018578 ┆ null      ┆ 0.002212 │\n",
      "└───────────┴───────────┴───────────┴───────────┴───┴───────────┴───────────┴───────────┴──────────┘\n",
      "\n",
      "每日预测样本数统计:\n",
      "  最小: 3147\n",
      "  最大: 3186\n",
      "  平均: 3173.69\n",
      "\n",
      "示例日期 20250102 的前10条预测:\n",
      "shape: (10, 4)\n",
      "┌───────────┬────────────┬─────────────────┬────────────┐\n",
      "│ ts_code   ┆ trade_date ┆ future_return_5 ┆ prediction │\n",
      "│ ---       ┆ ---        ┆ ---             ┆ ---        │\n",
      "│ str       ┆ str        ┆ f64             ┆ f64        │\n",
      "╞═══════════╪════════════╪═════════════════╪════════════╡\n",
      "│ 605507.SH ┆ 20250102   ┆ -0.058933       ┆ 0.006321   │\n",
      "│ 600993.SH ┆ 20250102   ┆ -0.024765       ┆ 0.002311   │\n",
      "│ 600817.SH ┆ 20250102   ┆ 0.007165        ┆ 0.011855   │\n",
      "│ 603896.SH ┆ 20250102   ┆ -0.044468       ┆ 0.013161   │\n",
      "│ 600754.SH ┆ 20250102   ┆ -0.062997       ┆ -0.002163  │\n",
      "│ 603008.SH ┆ 20250102   ┆ -0.018255       ┆ 0.008841   │\n",
      "│ 603650.SH ┆ 20250102   ┆ -0.005427       ┆ 0.008721   │\n",
      "│ 002236.SZ ┆ 20250102   ┆ -0.0513         ┆ 0.007152   │\n",
      "│ 603855.SH ┆ 20250102   ┆ -0.044197       ┆ 0.007929   │\n",
      "│ 002513.SZ ┆ 20250102   ┆ -0.020347       ┆ 0.02149    │\n",
      "└───────────┴────────────┴─────────────────┴────────────┘\n"
     ]
    }
   ],
   "execution_count": 32
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4 保存结果"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:08:16.296512Z",
     "start_time": "2026-03-08T15:08:15.970222Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"\\n\" + \"=\" * 80)\n",
    "print(\"保存预测结果\")\n",
    "print(\"=\" * 80)\n",
    "\n",
    "# 确保输出目录存在\n",
    "os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
    "\n",
    "# 生成时间戳\n",
    "start_dt = datetime.strptime(TEST_START, \"%Y%m%d\")\n",
    "end_dt = datetime.strptime(TEST_END, \"%Y%m%d\")\n",
    "date_str = f\"{start_dt.strftime('%Y%m%d')}_{end_dt.strftime('%Y%m%d')}\"\n",
    "\n",
    "# 保存每日 Top N\n",
    "print(f\"\\n[1/1] 保存每日 Top {TOP_N} 股票...\")\n",
    "topn_output_path = os.path.join(OUTPUT_DIR, f\"regression_output.csv\")\n",
    "\n",
    "# 按日期分组，取每日 top N\n",
    "topn_by_date = []\n",
    "unique_dates = results[\"trade_date\"].unique().sort()\n",
    "for date in unique_dates:\n",
    "    day_data = results.filter(results[\"trade_date\"] == date)\n",
    "    # 按 prediction 降序排序，取前 N\n",
    "    topn = day_data.sort(\"prediction\", descending=True).head(TOP_N)\n",
    "    topn_by_date.append(topn)\n",
    "\n",
    "# 合并所有日期的 top N\n",
    "topn_results = pl.concat(topn_by_date)\n",
    "\n",
    "# 格式化日期并调整列顺序：日期、分数、股票\n",
    "topn_to_save = topn_results.select(\n",
    "    [\n",
    "        pl.col(\"trade_date\").str.slice(0, 4)\n",
    "        + \"-\"\n",
    "        + pl.col(\"trade_date\").str.slice(4, 2)\n",
    "        + \"-\"\n",
    "        + pl.col(\"trade_date\").str.slice(6, 2).alias(\"date\"),\n",
    "        pl.col(\"prediction\").alias(\"score\"),\n",
    "        pl.col(\"ts_code\"),\n",
    "    ]\n",
    ")\n",
    "topn_to_save.write_csv(topn_output_path, include_header=True)\n",
    "print(f\"  保存路径: {topn_output_path}\")\n",
    "print(f\"  保存行数: {len(topn_to_save)}（{len(unique_dates)}个交易日 × 每日top{TOP_N}）\")\n",
    "print(f\"\\n  预览（前15行）:\")\n",
    "print(topn_to_save.head(15))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "================================================================================\n",
      "保存预测结果\n",
      "================================================================================\n",
      "\n",
      "[1/1] 保存每日 Top 5 股票...\n",
      "  保存路径: output\\regression_output.csv\n",
      "  保存行数: 1215（243个交易日 × 每日top5）\n",
      "\n",
      "  预览（前15行）:\n",
      "shape: (15, 3)\n",
      "┌────────────┬──────────┬───────────┐\n",
      "│ trade_date ┆ score    ┆ ts_code   │\n",
      "│ ---        ┆ ---      ┆ ---       │\n",
      "│ str        ┆ f64      ┆ str       │\n",
      "╞════════════╪══════════╪═══════════╡\n",
      "│ 2025-01-02 ┆ 0.124602 ┆ 603007.SH │\n",
      "│ 2025-01-02 ┆ 0.10774  ┆ 603559.SH │\n",
      "│ 2025-01-02 ┆ 0.059728 ┆ 603959.SH │\n",
      "│ 2025-01-02 ┆ 0.033194 ┆ 600804.SH │\n",
      "│ 2025-01-02 ┆ 0.03074  ┆ 600421.SH │\n",
      "│ …          ┆ …        ┆ …         │\n",
      "│ 2025-01-06 ┆ 0.131927 ┆ 603007.SH │\n",
      "│ 2025-01-06 ┆ 0.067151 ┆ 603959.SH │\n",
      "│ 2025-01-06 ┆ 0.049428 ┆ 603386.SH │\n",
      "│ 2025-01-06 ┆ 0.048319 ┆ 002046.SZ │\n",
      "│ 2025-01-06 ┆ 0.048007 ┆ 002759.SZ │\n",
      "└────────────┴──────────┴───────────┘\n"
     ]
    }
   ],
   "execution_count": 33
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.5 特征重要性"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:08:16.304039Z",
     "start_time": "2026-03-08T15:08:16.300741Z"
    }
   },
   "source": [
    "importance = model.feature_importance()\n",
    "if importance is not None:\n",
    "    print(\"\\n特征重要性:\")\n",
    "    print(importance.sort_values(ascending=False))\n",
    "\n",
    "print(\"\\n\" + \"=\" * 80)\n",
    "print(\"训练完成！\")\n",
    "print(\"=\" * 80)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "特征重要性:\n",
      "return_5_rank           2332.348582\n",
      "return_5                1950.969372\n",
      "turnover_rank           1887.661314\n",
      "return_10               1342.515739\n",
      "turnover_rate_std_20    1311.361422\n",
      "ma_ratio_5_20           1123.527241\n",
      "bbi_ratio               1071.855236\n",
      "high_low_ratio           994.522432\n",
      "bias_10                  742.095194\n",
      "std_return_5             741.347398\n",
      "volume_change_rate       739.034219\n",
      "return_20                597.878394\n",
      "volume_ratio_5_20        595.380527\n",
      "std_return_20            515.137529\n",
      "market_cap_rank          466.798819\n",
      "ma_20                    418.790501\n",
      "volatility_ratio         390.093624\n",
      "return_diff_5_10         354.139443\n",
      "turnover_rate_mean_5     351.775202\n",
      "turnover_deviation       177.305289\n",
      "ma_5                     150.850527\n",
      "volatility_5             148.218010\n",
      "volatility_20            147.523706\n",
      "dtype: float64\n",
      "\n",
      "================================================================================\n",
      "训练完成！\n",
      "================================================================================\n"
     ]
    }
   ],
   "execution_count": 34
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 可视化分析\n",
    "\n",
    "使用训练好的模型直接绘图。\n",
    "- **特征重要性图**：辅助特征选择\n",
    "- **决策树图**：理解决策逻辑"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:08:16.315496Z",
     "start_time": "2026-03-08T15:08:16.311483Z"
    }
   },
   "source": [
    "# 导入可视化库\n",
    "import matplotlib.pyplot as plt\n",
    "import lightgbm as lgb\n",
    "import pandas as pd\n",
    "\n",
    "# 从封装的model中取出底层Booster\n",
    "booster = model.model\n",
    "print(f\"模型类型: {type(booster)}\")\n",
    "print(f\"特征数量: {len(feature_cols)}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型类型: <class 'lightgbm.basic.Booster'>\n",
      "特征数量: 23\n"
     ]
    }
   ],
   "execution_count": 35
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1 绘制特征重要性（辅助特征选择）\n",
    "\n",
    "**解读**：\n",
    "- 重要性高的特征对模型贡献大\n",
    "- 重要性为0的特征可以考虑删除\n",
    "- 可以帮助理解哪些因子最有效"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2026-03-08T15:08:16.428810Z",
     "start_time": "2026-03-08T15:08:16.321345Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"绘制特征重要性...\")\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 8))\n",
    "lgb.plot_importance(\n",
    "    booster, \n",
    "    max_num_features=20,\n",
    "    importance_type='gain',\n",
    "    title='Feature Importance (Gain)',\n",
    "    ax=ax\n",
    ")\n",
    "ax.set_xlabel('Importance (Gain)')\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "# 打印重要性排名\n",
    "importance_gain = pd.Series(\n",
    "    booster.feature_importance(importance_type='gain'),\n",
    "    index=feature_cols\n",
    ").sort_values(ascending=False)\n",
    "\n",
    "print(\"\\n[特征重要性排名 - Gain]\")\n",
    "print(importance_gain)\n",
    "\n",
    "# 识别低重要性特征\n",
    "zero_importance = importance_gain[importance_gain == 0].index.tolist()\n",
    "if zero_importance:\n",
    "    print(f\"\\n[低重要性特征] 以下{len(zero_importance)}个特征重要性为0，可考虑删除:\")\n",
    "    for feat in zero_importance:\n",
    "        print(f\"  - {feat}\")\n",
    "else:\n",
    "    print(\"\\n所有特征都有一定重要性\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "绘制特征重要性...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ],
      "image/png": "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
     },
     "metadata": {},
     "output_type": "display_data",
     "jetTransient": {
      "display_id": null
     }
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "[特征重要性排名 - Gain]\n",
      "return_5_rank           2332.348582\n",
      "return_5                1950.969372\n",
      "turnover_rank           1887.661314\n",
      "return_10               1342.515739\n",
      "turnover_rate_std_20    1311.361422\n",
      "ma_ratio_5_20           1123.527241\n",
      "bbi_ratio               1071.855236\n",
      "high_low_ratio           994.522432\n",
      "bias_10                  742.095194\n",
      "std_return_5             741.347398\n",
      "volume_change_rate       739.034219\n",
      "return_20                597.878394\n",
      "volume_ratio_5_20        595.380527\n",
      "std_return_20            515.137529\n",
      "market_cap_rank          466.798819\n",
      "ma_20                    418.790501\n",
      "volatility_ratio         390.093624\n",
      "return_diff_5_10         354.139443\n",
      "turnover_rate_mean_5     351.775202\n",
      "turnover_deviation       177.305289\n",
      "ma_5                     150.850527\n",
      "volatility_5             148.218010\n",
      "volatility_20            147.523706\n",
      "dtype: float64\n",
      "\n",
      "所有特征都有一定重要性\n"
     ]
    }
   ],
   "execution_count": 36
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}