{
 "cells": [
  {
   "cell_type": "code",
   "id": "79a7758178bafdd3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:46:25.278301Z",
     "start_time": "2025-02-23T15:46:25.186393Z"
    }
   },
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import pandas as pd\n",
    "    \n",
    "\n",
    "    \n",
    "pd.set_option('display.max_columns', None)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "cell_type": "code",
   "id": "a79cafb06a7e0e43",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:47:12.994735Z",
     "start_time": "2025-02-23T15:46:25.278301Z"
    }
   },
   "source": [
    "from utils.utils import read_and_merge_h5_data\n",
    "\n",
    "print('daily data')\n",
    "df = read_and_merge_h5_data('../../data/daily_data.h5', key='daily_data',\n",
    "                            columns=['ts_code', 'trade_date', 'open', 'close', 'high', 'low', 'vol'],\n",
    "                            df=None)\n",
    "\n",
    "print('daily basic')\n",
    "df = read_and_merge_h5_data('../../data/daily_basic.h5', key='daily_basic',\n",
    "                            columns=['ts_code', 'trade_date', 'turnover_rate', 'pe_ttm', 'circ_mv', 'volume_ratio',\n",
    "                                     'is_st'], df=df, join='inner')\n",
    "\n",
    "print('stk limit')\n",
    "df = read_and_merge_h5_data('../../data/stk_limit.h5', key='stk_limit',\n",
    "                            columns=['ts_code', 'trade_date', 'pre_close', 'up_limit', 'down_limit'],\n",
    "                            df=df)\n",
    "print('money flow')\n",
    "df = read_and_merge_h5_data('../../data/money_flow.h5', key='money_flow',\n",
    "                            columns=['ts_code', 'trade_date', 'buy_sm_vol', 'sell_sm_vol', 'buy_lg_vol', 'sell_lg_vol',\n",
    "                                     'buy_elg_vol', 'sell_elg_vol', 'net_mf_vol'],\n",
    "                            df=df)\n",
    "print(df.info())"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "daily data\n",
      "daily basic\n",
      "inner merge on ['ts_code', 'trade_date']\n",
      "stk limit\n",
      "left merge on ['ts_code', 'trade_date']\n",
      "money flow\n",
      "left merge on ['ts_code', 'trade_date']\n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 8296325 entries, 0 to 8296324\n",
      "Data columns (total 21 columns):\n",
      " #   Column         Dtype         \n",
      "---  ------         -----         \n",
      " 0   ts_code        object        \n",
      " 1   trade_date     datetime64[ns]\n",
      " 2   open           float64       \n",
      " 3   close          float64       \n",
      " 4   high           float64       \n",
      " 5   low            float64       \n",
      " 6   vol            float64       \n",
      " 7   turnover_rate  float64       \n",
      " 8   pe_ttm         float64       \n",
      " 9   circ_mv        float64       \n",
      " 10  volume_ratio   float64       \n",
      " 11  is_st          bool          \n",
      " 12  up_limit       float64       \n",
      " 13  down_limit     float64       \n",
      " 14  buy_sm_vol     float64       \n",
      " 15  sell_sm_vol    float64       \n",
      " 16  buy_lg_vol     float64       \n",
      " 17  sell_lg_vol    float64       \n",
      " 18  buy_elg_vol    float64       \n",
      " 19  sell_elg_vol   float64       \n",
      " 20  net_mf_vol     float64       \n",
      "dtypes: bool(1), datetime64[ns](1), float64(18), object(1)\n",
      "memory usage: 1.2+ GB\n",
      "None\n"
     ]
    }
   ],
   "execution_count": 23
  },
  {
   "cell_type": "code",
   "id": "f7a55c19-b7dc-4d2f-a478-cffab11690df",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:47:14.883651Z",
     "start_time": "2025-02-23T15:47:13.089165Z"
    }
   },
   "source": [
    "print('industry')\n",
    "df = read_and_merge_h5_data('../../data/industry_data.h5', key='industry_data',\n",
    "                            columns=['ts_code', 'l2_code'],\n",
    "                            df=df, on=['ts_code'], join='left')\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "industry\n",
      "left merge on ['ts_code']\n"
     ]
    }
   ],
   "execution_count": 24
  },
  {
   "cell_type": "code",
   "id": "4077d4449d406c86",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:47:15.140211Z",
     "start_time": "2025-02-23T15:47:14.978172Z"
    }
   },
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "def calculate_indicators(df):\n",
    "    \"\"\"\n",
    "    计算四个指标：当日涨跌幅、5日移动平均、RSI、MACD。\n",
    "    \"\"\"\n",
    "    df['daily_return'] = (df['close'] - df['pre_close']) / df['pre_close'] * 100\n",
    "    # df['5_day_ma'] = df['close'].rolling(window=5).mean()\n",
    "    delta = df['close'].diff()\n",
    "    gain = delta.where(delta > 0, 0)\n",
    "    loss = -delta.where(delta < 0, 0)\n",
    "    avg_gain = gain.rolling(window=14).mean()\n",
    "    avg_loss = loss.rolling(window=14).mean()\n",
    "    rs = avg_gain / avg_loss\n",
    "    df['RSI'] = 100 - (100 / (1 + rs))\n",
    "\n",
    "    # 计算MACD\n",
    "    ema12 = df['close'].ewm(span=12, adjust=False).mean()\n",
    "    ema26 = df['close'].ewm(span=26, adjust=False).mean()\n",
    "    df['MACD'] = ema12 - ema26\n",
    "    df['Signal_line'] = df['MACD'].ewm(span=9, adjust=False).mean()\n",
    "    df['MACD_hist'] = df['MACD'] - df['Signal_line']\n",
    "\n",
    "    return df\n",
    "\n",
    "def generate_index_indicators(h5_filename):\n",
    "    df = pd.read_hdf(h5_filename, key='index_data')\n",
    "    df['trade_date'] = pd.to_datetime(df['trade_date'], format='%Y%m%d')\n",
    "    df = df.sort_values('trade_date')\n",
    "\n",
    "    # 计算每个ts_code的相关指标\n",
    "    df_indicators = []\n",
    "    for ts_code in df['ts_code'].unique():\n",
    "        df_index = df[df['ts_code'] == ts_code].copy()\n",
    "        df_index = calculate_indicators(df_index)\n",
    "        df_indicators.append(df_index)\n",
    "\n",
    "    # 合并所有指数的结果\n",
    "    df_all_indicators = pd.concat(df_indicators, ignore_index=True)\n",
    "\n",
    "    # 保留trade_date列，并将同一天的数据按ts_code合并成一行\n",
    "    df_final = df_all_indicators.pivot_table(\n",
    "        index='trade_date',\n",
    "        columns='ts_code',\n",
    "        values=['daily_return', 'RSI', 'MACD', 'Signal_line', 'MACD_hist'],\n",
    "        aggfunc='last'\n",
    "    )\n",
    "\n",
    "    df_final.columns = [f\"{col[1]}_{col[0]}\" for col in df_final.columns]\n",
    "    df_final = df_final.reset_index()\n",
    "\n",
    "    return df_final\n",
    "\n",
    "\n",
    "# 使用函数\n",
    "h5_filename = '../../data/index_data.h5'\n",
    "index_data = generate_index_indicators(h5_filename)\n",
    "index_data = index_data.dropna()\n"
   ],
   "outputs": [],
   "execution_count": 25
  },
  {
   "cell_type": "code",
   "id": "c4e9e1d31da6dba6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:47:15.338283Z",
     "start_time": "2025-02-23T15:47:15.234691Z"
    }
   },
   "source": [
    "import numpy as np\n",
    "import talib\n",
    "\n",
    "def get_technical_factor(df):\n",
    "    # 按股票和日期排序\n",
    "    df = df.sort_values(by=['ts_code', 'trade_date'])\n",
    "    grouped = df.groupby('ts_code', group_keys=False)\n",
    "\n",
    "    # 计算 up 和 down\n",
    "    df['log_close'] = np.log(df['close'])\n",
    "\n",
    "    df['up'] = (df['high'] - df[['close', 'open']].max(axis=1)) / df['close']\n",
    "    df['down'] = (df[['close', 'open']].min(axis=1) - df['low']) / df['close']\n",
    "\n",
    "    # 计算 ATR\n",
    "    df['atr_14'] = grouped.apply(\n",
    "        lambda x: pd.Series(talib.ATR(x['high'].values, x['low'].values, x['close'].values, timeperiod=14), index=x.index)\n",
    "    )\n",
    "    df['atr_6'] = grouped.apply(\n",
    "        lambda x: pd.Series(talib.ATR(x['high'].values, x['low'].values, x['close'].values, timeperiod=6), index=x.index)\n",
    "    )\n",
    "\n",
    "    # 计算 OBV 及其均线\n",
    "    df['obv'] = grouped.apply(\n",
    "        lambda x: pd.Series(talib.OBV(x['close'].values, x['vol'].values), index=x.index)\n",
    "    )\n",
    "    df['maobv_6'] = grouped.apply(\n",
    "        lambda x: pd.Series(talib.SMA(x['obv'].values, timeperiod=6), index=x.index)\n",
    "    )\n",
    "    df['obv-maobv_6'] = df['obv'] - df['maobv_6']\n",
    "\n",
    "    # 计算 RSI\n",
    "    df['rsi_3'] = grouped.apply(\n",
    "        lambda x: pd.Series(talib.RSI(x['close'].values, timeperiod=3), index=x.index)\n",
    "    )\n",
    "    df['rsi_6'] = grouped.apply(\n",
    "        lambda x: pd.Series(talib.RSI(x['close'].values, timeperiod=6), index=x.index)\n",
    "    )\n",
    "    df['rsi_9'] = grouped.apply(\n",
    "        lambda x: pd.Series(talib.RSI(x['close'].values, timeperiod=9), index=x.index)\n",
    "    )\n",
    "\n",
    "    # 计算 return_10 和 return_20\n",
    "    df['return_5'] = grouped['close'].apply(lambda x: x / x.shift(5) - 1)\n",
    "    df['return_10'] = grouped['close'].apply(lambda x: x / x.shift(10) - 1)\n",
    "    df['return_20'] = grouped['close'].apply(lambda x: x / x.shift(20) - 1)\n",
    "\n",
    "    # 计算 avg_close_5\n",
    "    df['avg_close_5'] = grouped['close'].apply(lambda x: x.rolling(window=5).mean() / x)\n",
    "\n",
    "    # 计算标准差指标\n",
    "    df['std_return_5'] = grouped['close'].apply(lambda x: x.pct_change().rolling(window=5).std())\n",
    "    df['std_return_15'] = grouped['close'].apply(lambda x: x.pct_change().rolling(window=15).std())\n",
    "    df['std_return_25'] = grouped['close'].apply(lambda x: x.pct_change().rolling(window=25).std())\n",
    "    df['std_return_90'] = grouped['close'].apply(lambda x: x.pct_change().rolling(window=90).std())\n",
    "    df['std_return_90_2'] = grouped['close'].apply(lambda x: x.shift(10).pct_change().rolling(window=90).std())\n",
    "\n",
    "    # 计算比值指标\n",
    "    df['std_return_5 / std_return_90'] = df['std_return_5'] / df['std_return_90']\n",
    "    df['std_return_5 / std_return_25'] = df['std_return_5'] / df['std_return_25']\n",
    "\n",
    "    # 计算标准差差值\n",
    "    df['std_return_90 - std_return_90_2'] = df['std_return_90'] - df['std_return_90_2']\n",
    "\n",
    "    return df\n",
    "\n",
    "\n",
    "def get_act_factor(df, cat=True):\n",
    "    # 按股票和日期排序\n",
    "    df = df.sort_values(by=['ts_code', 'trade_date'])\n",
    "    grouped = df.groupby('ts_code', group_keys=False)\n",
    "    # 计算 EMA 指标\n",
    "    df['ema_5'] = grouped['close'].apply(\n",
    "        lambda x: pd.Series(talib.EMA(x.values, timeperiod=5), index=x.index)\n",
    "    )\n",
    "    df['ema_13'] = grouped['close'].apply(\n",
    "        lambda x: pd.Series(talib.EMA(x.values, timeperiod=13), index=x.index)\n",
    "    )\n",
    "    df['ema_20'] = grouped['close'].apply(\n",
    "        lambda x: pd.Series(talib.EMA(x.values, timeperiod=20), index=x.index)\n",
    "    )\n",
    "    df['ema_60'] = grouped['close'].apply(\n",
    "        lambda x: pd.Series(talib.EMA(x.values, timeperiod=60), index=x.index)\n",
    "    )\n",
    "\n",
    "    # 计算 act_factor1, act_factor2, act_factor3, act_factor4\n",
    "    df['act_factor1'] = grouped['ema_5'].apply(\n",
    "        lambda x: np.arctan((x / x.shift(1) - 1) * 100) * 57.3 / 50\n",
    "    )\n",
    "    df['act_factor2'] = grouped['ema_13'].apply(\n",
    "        lambda x: np.arctan((x / x.shift(1) - 1) * 100) * 57.3 / 40\n",
    "    )\n",
    "    df['act_factor3'] = grouped['ema_20'].apply(\n",
    "        lambda x: np.arctan((x / x.shift(1) - 1) * 100) * 57.3 / 21\n",
    "    )\n",
    "    df['act_factor4'] = grouped['ema_60'].apply(\n",
    "        lambda x: np.arctan((x / x.shift(1) - 1) * 100) * 57.3 / 10\n",
    "    )\n",
    "\n",
    "    if cat:\n",
    "        df['cat_af1'] = df['act_factor1'] > 0\n",
    "        df['cat_af2'] = df['act_factor2'] > df['act_factor1']\n",
    "        df['cat_af3'] = df['act_factor3'] > df['act_factor2']\n",
    "        df['cat_af4'] = df['act_factor4'] > df['act_factor3']\n",
    "\n",
    "    # 计算 act_factor5 和 act_factor6\n",
    "    df['act_factor5'] = df['act_factor1'] + df['act_factor2'] + df['act_factor3'] + df['act_factor4']\n",
    "    df['act_factor6'] = (df['act_factor1'] - df['act_factor2']) / np.sqrt(df['act_factor1']**2 + df['act_factor2']**2)\n",
    "\n",
    "    # 根据 trade_date 截面计算排名\n",
    "    df['rank_act_factor1'] = df.groupby('trade_date', group_keys=False)['act_factor1'].rank(ascending=False, pct=True)\n",
    "    df['rank_act_factor2'] = df.groupby('trade_date', group_keys=False)['act_factor2'].rank(ascending=False, pct=True)\n",
    "    df['rank_act_factor3'] = df.groupby('trade_date', group_keys=False)['act_factor3'].rank(ascending=False, pct=True)\n",
    "\n",
    "    return df\n",
    "\n",
    "\n",
    "def get_money_flow_factor(df):\n",
    "    # 计算资金流相关因子（字段名称见 tushare 数据说明）\n",
    "    df['active_buy_volume_large'] = df['buy_lg_vol'] / df['net_mf_vol']\n",
    "    df['active_buy_volume_big'] = df['buy_elg_vol'] / df['net_mf_vol']\n",
    "    df['active_buy_volume_small'] = df['buy_sm_vol'] / df['net_mf_vol']\n",
    "\n",
    "    df['buy_lg_vol_minus_sell_lg_vol'] = (df['buy_lg_vol'] - df['sell_lg_vol']) / df['net_mf_vol']\n",
    "    df['buy_elg_vol_minus_sell_elg_vol'] = (df['buy_elg_vol'] - df['sell_elg_vol']) / df['net_mf_vol']\n",
    "\n",
    "    df['log(circ_mv)'] = np.log(df['circ_mv'])\n",
    "    return df\n",
    "\n",
    "\n",
    "def get_alpha_factor(df):\n",
    "    df = df.sort_values(by=['ts_code', 'trade_date'])\n",
    "    grouped = df.groupby('ts_code')\n",
    "\n",
    "    # alpha_022: 当前 close 与 5 日前 close 差值\n",
    "    df['alpha_022'] = grouped['close'].transform(lambda x: x - x.shift(5))\n",
    "\n",
    "    # alpha_003: (close - open) / (high - low)\n",
    "    df['alpha_003'] = np.where(df['high'] != df['low'],\n",
    "                               (df['close'] - df['open']) / (df['high'] - df['low']),\n",
    "                               0)\n",
    "\n",
    "    # alpha_007: 计算过去5日 close 与 vol 的相关性，并按 trade_date 排名\n",
    "    df['alpha_007'] = grouped.apply(lambda x: x['close'].rolling(5).corr(x['vol'])).reset_index(level=0, drop=True)\n",
    "    df['alpha_007'] = df.groupby('trade_date', group_keys=False)['alpha_007'].rank(ascending=True, pct=True)\n",
    "\n",
    "    # alpha_013: 计算过去5日 close 之和 - 20日 close 之和，并按 trade_date 排名\n",
    "    df['alpha_013'] = grouped['close'].transform(lambda x: x.rolling(5).sum() - x.rolling(20).sum())\n",
    "    df['alpha_013'] = df.groupby('trade_date', group_keys=False)['alpha_013'].rank(ascending=True, pct=True)\n",
    "\n",
    "    return df\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 26
  },
  {
   "cell_type": "code",
   "id": "a735bc02ceb4d872",
   "metadata": {
    "jupyter": {
     "source_hidden": true,
     "is_executing": true
    },
    "ExecuteTime": {
     "start_time": "2025-02-23T15:47:15.450197Z"
    }
   },
   "source": [
    "def read_industry_data(h5_filename):\n",
    "    # 读取 H5 文件中所有的行业数据\n",
    "    industry_data = pd.read_hdf(h5_filename, key='sw_daily', columns=[\n",
    "        'ts_code', 'trade_date', 'open', 'close', 'high', 'low', 'pe', 'pb', 'vol'\n",
    "    ])  # 假设 H5 文件的键是 'industry_data'\n",
    "    industry_data = industry_data.reindex()\n",
    "    industry_data['trade_date'] = pd.to_datetime(df['trade_date'], format='%Y%m%d')\n",
    "\n",
    "    grouped = industry_data.groupby('ts_code', group_keys=False)\n",
    "    industry_data['obv'] = grouped.apply(\n",
    "        lambda x: pd.Series(talib.OBV(x['close'].values, x['vol'].values), index=x.index)\n",
    "    )\n",
    "    industry_data['return_5'] = grouped['close'].apply(lambda x: x / x.shift(5) - 1)\n",
    "    # industry_data['return_20'] = grouped['close'].apply(lambda x: x / x.shift(20) - 1)\n",
    "\n",
    "    # industry_data = get_act_factor(industry_data, cat=False)\n",
    "    # industry_data = industry_data.sort_values(by=['trade_date', 'ts_code'])\n",
    "\n",
    "    # 计算每天每个 ts_code 的因子和当天所有 ts_code 的中位数的偏差\n",
    "    factor_columns = ['obv', 'return_5', 'return_20', 'act_factor1', 'act_factor2', 'act_factor3', 'act_factor4']  # 因子列\n",
    "\n",
    "    for factor in factor_columns:\n",
    "        if factor in industry_data.columns:\n",
    "            # 计算每天每个 ts_code 的因子值与当天所有 ts_code 的中位数的偏差\n",
    "            industry_data[f'{factor}_deviation'] = industry_data.groupby('trade_date')[factor].transform(lambda x: x - x.median())\n",
    "\n",
    "    industry_data['return_5_percentile'] = industry_data.groupby('trade_date')['return_5'].transform(lambda x: x.rank(pct=True))\n",
    "    industry_data = industry_data.drop(columns=['open', 'close', 'high', 'low', 'pe', 'pb', 'vol'])\n",
    "\n",
    "\n",
    "    industry_data = industry_data.rename(\n",
    "        columns={col: f'industry_{col}' for col in industry_data.columns if col not in ['ts_code', 'trade_date']})\n",
    "\n",
    "    industry_data = industry_data.rename(columns={'ts_code': 'cat_l2_code'})\n",
    "    return industry_data\n",
    "\n",
    "industry_df = read_industry_data('../../data/sw_daily.h5')\n"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "53f86ddc0677a6d7",
   "metadata": {
    "scrolled": true,
    "ExecuteTime": {
     "end_time": "2025-02-23T15:38:37.800520Z",
     "start_time": "2025-02-23T15:38:37.753477Z"
    }
   },
   "source": [
    "origin_columns = df.columns.tolist()\n",
    "origin_columns = [col for col in origin_columns if col not in ['turnover_rate', 'pe_ttm', 'volume_ratio', 'l2_code']]\n",
    "origin_columns = [col for col in origin_columns if col not in index_data.columns]\n"
   ],
   "outputs": [],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "id": "dbe2fd8021b9417f",
   "metadata": {
    "scrolled": true,
    "ExecuteTime": {
     "end_time": "2025-02-23T15:39:35.360052Z",
     "start_time": "2025-02-23T15:38:37.818014Z"
    }
   },
   "source": [
    "def filter_data(df):\n",
    "    # df = df.groupby('trade_date').apply(lambda x: x.nlargest(1000, 'act_factor1'))\n",
    "    df = df[~df['is_st']]\n",
    "    df = df[~df['ts_code'].str.endswith('BJ')]\n",
    "    df = df[~df['ts_code'].str.startswith('30')]\n",
    "    df = df[~df['ts_code'].str.startswith('68')]\n",
    "    df = df[~df['ts_code'].str.startswith('8')]\n",
    "    df = df.reset_index(drop=True)\n",
    "    return df\n",
    "\n",
    "\n",
    "df = filter_data(df)\n",
    "df = get_technical_factor(df)\n",
    "df = get_act_factor(df)\n",
    "df = get_money_flow_factor(df)\n",
    "df = get_alpha_factor(df)\n",
    "# df = df.merge(industry_df, on=['l2_code', 'trade_date'], how='left')\n",
    "df = df.rename(columns={'l2_code': 'cat_l2_code'})\n",
    "# df = df.merge(index_data, on='trade_date', how='left')\n",
    "\n",
    "print(df.info())"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Index: 5538535 entries, 1962 to 5538534\n",
      "Data columns (total 72 columns):\n",
      " #   Column                           Dtype         \n",
      "---  ------                           -----         \n",
      " 0   ts_code                          object        \n",
      " 1   trade_date                       datetime64[ns]\n",
      " 2   open                             float64       \n",
      " 3   close                            float64       \n",
      " 4   high                             float64       \n",
      " 5   low                              float64       \n",
      " 6   vol                              float64       \n",
      " 7   turnover_rate                    float64       \n",
      " 8   pe_ttm                           float64       \n",
      " 9   circ_mv                          float64       \n",
      " 10  volume_ratio                     float64       \n",
      " 11  is_st                            bool          \n",
      " 12  up_limit                         float64       \n",
      " 13  down_limit                       float64       \n",
      " 14  buy_sm_vol                       float64       \n",
      " 15  sell_sm_vol                      float64       \n",
      " 16  buy_lg_vol                       float64       \n",
      " 17  sell_lg_vol                      float64       \n",
      " 18  buy_elg_vol                      float64       \n",
      " 19  sell_elg_vol                     float64       \n",
      " 20  net_mf_vol                       float64       \n",
      " 21  cat_l2_code                      object        \n",
      " 22  log_close                        float64       \n",
      " 23  up                               float64       \n",
      " 24  down                             float64       \n",
      " 25  atr_14                           float64       \n",
      " 26  atr_6                            float64       \n",
      " 27  obv                              float64       \n",
      " 28  maobv_6                          float64       \n",
      " 29  obv-maobv_6                      float64       \n",
      " 30  rsi_3                            float64       \n",
      " 31  rsi_6                            float64       \n",
      " 32  rsi_9                            float64       \n",
      " 33  return_5                         float64       \n",
      " 34  return_10                        float64       \n",
      " 35  return_20                        float64       \n",
      " 36  avg_close_5                      float64       \n",
      " 37  std_return_5                     float64       \n",
      " 38  std_return_15                    float64       \n",
      " 39  std_return_25                    float64       \n",
      " 40  std_return_90                    float64       \n",
      " 41  std_return_90_2                  float64       \n",
      " 42  std_return_5 / std_return_90     float64       \n",
      " 43  std_return_5 / std_return_25     float64       \n",
      " 44  std_return_90 - std_return_90_2  float64       \n",
      " 45  ema_5                            float64       \n",
      " 46  ema_13                           float64       \n",
      " 47  ema_20                           float64       \n",
      " 48  ema_60                           float64       \n",
      " 49  act_factor1                      float64       \n",
      " 50  act_factor2                      float64       \n",
      " 51  act_factor3                      float64       \n",
      " 52  act_factor4                      float64       \n",
      " 53  cat_af1                          bool          \n",
      " 54  cat_af2                          bool          \n",
      " 55  cat_af3                          bool          \n",
      " 56  cat_af4                          bool          \n",
      " 57  act_factor5                      float64       \n",
      " 58  act_factor6                      float64       \n",
      " 59  rank_act_factor1                 float64       \n",
      " 60  rank_act_factor2                 float64       \n",
      " 61  rank_act_factor3                 float64       \n",
      " 62  active_buy_volume_large          float64       \n",
      " 63  active_buy_volume_big            float64       \n",
      " 64  active_buy_volume_small          float64       \n",
      " 65  buy_lg_vol_minus_sell_lg_vol     float64       \n",
      " 66  buy_elg_vol_minus_sell_elg_vol   float64       \n",
      " 67  log(circ_mv)                     float64       \n",
      " 68  alpha_022                        float64       \n",
      " 69  alpha_003                        float64       \n",
      " 70  alpha_007                        float64       \n",
      " 71  alpha_013                        float64       \n",
      "dtypes: bool(5), datetime64[ns](1), float64(64), object(2)\n",
      "memory usage: 2.8+ GB\n",
      "None\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:39:35.623327Z",
     "start_time": "2025-02-23T15:39:35.485449Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def create_deviation_within_dates(df, feature_columns):\n",
    "    groupby_col = 'cat_l2_code'  # 使用 trade_date 进行分组\n",
    "    new_columns = {}\n",
    "    ret_feature_columns = feature_columns[:]\n",
    "\n",
    "    # 自动选择所有数值型特征\n",
    "    num_features = [col for col in feature_columns if 'cat' not in col and 'index' not in col]\n",
    "    num_features = [col for col in feature_columns if 'cat' not in col and 'industry' not in col]\n",
    "\n",
    "    # 遍历所有数值型特征\n",
    "    for feature in num_features:\n",
    "        if feature == 'trade_date':  # 不需要对 'trade_date' 计算偏差\n",
    "            continue\n",
    "\n",
    "        grouped_median = df.groupby(['trade_date', groupby_col])[feature].transform('median')\n",
    "        deviation_col_name = f'deviation_median_{feature}'\n",
    "        new_columns[deviation_col_name] = df[feature] - grouped_median\n",
    "        ret_feature_columns.append(deviation_col_name)\n",
    "\n",
    "        grouped_mean = df.groupby(groupby_col)[feature].transform('mean')\n",
    "        deviation_col_name = f'deviation_mean_{feature}'\n",
    "        new_columns[deviation_col_name] = df[feature] - grouped_mean\n",
    "        ret_feature_columns.append(deviation_col_name)\n",
    "\n",
    "    # 将新计算的偏差特征与原始 DataFrame 合并\n",
    "    df = pd.concat([df, pd.DataFrame(new_columns)], axis=1)\n",
    "\n",
    "    # for feature in ['obv', 'return_20', 'act_factor1', 'act_factor2', 'act_factor3', 'act_factor4']:\n",
    "    #     df[f'deviation_industry_{feature}'] = df[feature] - df[f'industry_{feature}']\n",
    "\n",
    "    return df, ret_feature_columns\n"
   ],
   "id": "d345bcc43b15579e",
   "outputs": [],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "id": "5f3d9aece75318cd",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:40:13.266857Z",
     "start_time": "2025-02-23T15:39:35.672924Z"
    }
   },
   "source": [
    "def get_qcuts(series, quantiles):\n",
    "    q = pd.qcut(series, q=quantiles, labels=False, duplicates='drop')\n",
    "    return q[-1]  # 返回窗口最后一个元素的分位数标签\n",
    "\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "def remove_outliers_label_percentile(label: pd.Series, lower_percentile: float = 0.01, upper_percentile: float = 0.99):\n",
    "    if not (0 <= lower_percentile < upper_percentile <= 1):\n",
    "        raise ValueError(\"Percentile values must satisfy 0 <= lower_percentile < upper_percentile <= 1.\")\n",
    "\n",
    "    # Calculate lower and upper bounds based on percentiles\n",
    "    lower_bound = label.quantile(lower_percentile)\n",
    "    upper_bound = label.quantile(upper_percentile)\n",
    "\n",
    "    # Filter out values outside the bounds\n",
    "    filtered_label = label[(label >= lower_bound) & (label <= upper_bound)]\n",
    "\n",
    "    # Print the number of removed outliers\n",
    "    print(f\"Removed {len(label) - len(filtered_label)} outliers.\")\n",
    "    return filtered_label\n",
    "\n",
    "\n",
    "def calculate_risk_adjusted_target(df, days=5):\n",
    "    df = df.sort_values(by=['ts_code', 'trade_date'])\n",
    "\n",
    "    df['future_close'] = df.groupby('ts_code')['close'].shift(-days)\n",
    "    df['future_return'] = (df['future_close'] - df['close']) / df['close']\n",
    "\n",
    "    df['future_volatility'] = df.groupby('ts_code')['future_return'].rolling(days, min_periods=1).std().reset_index(\n",
    "        level=0, drop=True)\n",
    "    df['sharpe_ratio'] = df['future_return'] * df['future_volatility']\n",
    "    df['sharpe_ratio'].replace([np.inf, -np.inf], np.nan, inplace=True)\n",
    "\n",
    "    return df['sharpe_ratio']\n",
    "\n",
    "\n",
    "future_close = df.groupby('ts_code')['close'].shift(-4)\n",
    "future_return = (future_close - df['close']) / df['close']\n",
    "df['label'] = future_return\n",
    "df['label'] = remove_outliers_label_percentile(df['label'])\n",
    "\n",
    "# df = df.apply(lambda x: x.astype('float32') if x.dtype in ['float64', 'float32'] else x)\n",
    "df = df.sort_values(by=['trade_date', 'ts_code'])\n",
    "train_data = df[(df['trade_date'] <= '2023-01-01') & (df['trade_date'] >= '2016-01-01')]\n",
    "test_data = df[df['trade_date'] >= '2023-01-01']\n",
    "\n",
    "train_data = train_data.merge(industry_df, on=['cat_l2_code', 'trade_date'], how='left')\n",
    "# train_data = train_data.merge(index_data, on='trade_date', how='left')\n",
    "test_data = test_data.merge(industry_df, on=['cat_l2_code', 'trade_date'], how='left')\n",
    "# test_data = test_data.merge(index_data, on='trade_date', how='left')\n",
    "\n",
    "train_data = train_data.groupby('trade_date', group_keys=False).apply(lambda x: x.nlargest(1000, 'return_20'))\n",
    "test_data = test_data.groupby('trade_date', group_keys=False).apply(lambda x: x.nlargest(1000, 'return_20'))\n",
    "\n",
    "train_data, test_data = train_data.replace([np.inf, -np.inf], np.nan), test_data.replace([np.inf, -np.inf], np.nan)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removed 123852 outliers.\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:40:13.500203Z",
     "start_time": "2025-02-23T15:40:13.345289Z"
    }
   },
   "cell_type": "code",
   "source": [
    "feature_columns = [col for col in train_data.columns if col not in ['trade_date',\n",
    "                                                            'ts_code',\n",
    "                                                            'label']]\n",
    "feature_columns = [col for col in feature_columns if 'future' not in col]\n",
    "feature_columns = [col for col in feature_columns if 'score' not in col]\n",
    "feature_columns = [col for col in feature_columns if col not in origin_columns]\n",
    "feature_columns = [col for col in feature_columns if not col.startswith('_')]\n",
    "print(feature_columns)"
   ],
   "id": "93d47ef451968346",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['turnover_rate', 'pe_ttm', 'volume_ratio', 'cat_l2_code', 'log_close', 'up', 'down', 'atr_14', 'atr_6', 'obv', 'maobv_6', 'obv-maobv_6', 'rsi_3', 'rsi_6', 'rsi_9', 'return_5', 'return_10', 'return_20', 'avg_close_5', 'std_return_5', 'std_return_15', 'std_return_25', 'std_return_90', 'std_return_90_2', 'std_return_5 / std_return_90', 'std_return_5 / std_return_25', 'std_return_90 - std_return_90_2', 'ema_5', 'ema_13', 'ema_20', 'ema_60', 'act_factor1', 'act_factor2', 'act_factor3', 'act_factor4', 'cat_af1', 'cat_af2', 'cat_af3', 'cat_af4', 'act_factor5', 'act_factor6', 'rank_act_factor1', 'rank_act_factor2', 'rank_act_factor3', 'active_buy_volume_large', 'active_buy_volume_big', 'active_buy_volume_small', 'buy_lg_vol_minus_sell_lg_vol', 'buy_elg_vol_minus_sell_elg_vol', 'log(circ_mv)', 'alpha_022', 'alpha_003', 'alpha_007', 'alpha_013', 'industry_obv', 'industry_return_5', 'industry_obv_deviation', 'industry_return_5_deviation', 'industry_return_5_percentile', '000852.SH_MACD', '000905.SH_MACD', '399006.SZ_MACD', '000852.SH_MACD_hist', '000905.SH_MACD_hist', '399006.SZ_MACD_hist', '000852.SH_RSI', '000905.SH_RSI', '399006.SZ_RSI', '000852.SH_Signal_line', '000905.SH_Signal_line', '399006.SZ_Signal_line', '000852.SH_daily_return', '000905.SH_daily_return', '399006.SZ_daily_return']\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:40:34.827593Z",
     "start_time": "2025-02-23T15:40:13.547615Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# feature_columns_new = feature_columns[:]\n",
    "train_data, feature_columns_new = create_deviation_within_dates(train_data, feature_columns)\n",
    "print(f'feature_columns size: {len(feature_columns_new)}')\n",
    "test_data, feature_columns_new = create_deviation_within_dates(test_data, feature_columns)\n",
    "print(f'feature_columns size: {len(feature_columns_new)}')\n",
    "\n",
    "train_data = train_data.dropna(subset=feature_columns_new)\n",
    "train_data = train_data.dropna(subset=['label'])\n",
    "train_data = train_data.reset_index(drop=True)\n",
    "\n",
    "test_data = test_data.dropna(subset=feature_columns_new)\n",
    "test_data = test_data.dropna(subset=['label'])\n",
    "test_data = test_data.reset_index(drop=True)\n",
    "\n",
    "print(len(train_data))\n",
    "print(f\"最小日期: {train_data['trade_date'].min().strftime('%Y-%m-%d')}\")\n",
    "print(f\"最大日期: {train_data['trade_date'].max().strftime('%Y-%m-%d')}\")\n",
    "print(len(test_data))\n",
    "print(f\"最小日期: {test_data['trade_date'].min().strftime('%Y-%m-%d')}\")\n",
    "print(f\"最大日期: {test_data['trade_date'].max().strftime('%Y-%m-%d')}\")"
   ],
   "id": "572576eea818c865",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "feature_columns size: 202\n",
      "feature_columns size: 202\n",
      "807303\n",
      "最小日期: 2017-03-21\n",
      "最大日期: 2022-12-30\n",
      "297608\n",
      "最小日期: 2023-01-03\n",
      "最大日期: 2025-02-10\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:40:35.116436Z",
     "start_time": "2025-02-23T15:40:34.974047Z"
    }
   },
   "cell_type": "code",
   "source": [
    "cat_columns = [col for col in df.columns if col.startswith('cat')]\n",
    "for col in cat_columns:\n",
    "    train_data[col] = train_data[col].astype('category')\n",
    "    test_data[col] = test_data[col].astype('category')"
   ],
   "id": "2d7e37432f551aea",
   "outputs": [],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "id": "8f134d435f71e9e2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:40:36.646379Z",
     "start_time": "2025-02-23T15:40:35.116436Z"
    }
   },
   "source": [
    "import lightgbm as lgb\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import optuna\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "import os\n",
    "import json\n",
    "import pickle\n",
    "import hashlib\n",
    "from catboost import Pool\n",
    "\n",
    "def train_light_model(train_data_df, test_data_df, params, feature_columns, callbacks, evals,\n",
    "                      print_feature_importance=True, num_boost_round=100,\n",
    "                      use_optuna=False):\n",
    "    train_data_df, test_data_df = train_data_df.dropna(subset=['label']), test_data_df.dropna(subset=['label'])\n",
    "    X_train = train_data_df[feature_columns]\n",
    "    y_train = train_data_df['label']\n",
    "\n",
    "    X_val = test_data_df[feature_columns]\n",
    "    y_val = test_data_df['label']\n",
    "\n",
    "    categorical_feature = [i for i, col in enumerate(feature_columns) if col.startswith('cat')]\n",
    "    print(f'categorical_feature: {categorical_feature}')\n",
    "    train_data = lgb.Dataset(X_train, label=y_train, categorical_feature=categorical_feature)\n",
    "    val_data = lgb.Dataset(X_val, label=y_val, categorical_feature=categorical_feature)\n",
    "    model = lgb.train(\n",
    "        params, train_data, num_boost_round=num_boost_round,\n",
    "        valid_sets=[train_data, val_data], valid_names=['train', 'valid'],\n",
    "        callbacks=callbacks\n",
    "    )\n",
    "\n",
    "    if print_feature_importance:\n",
    "        lgb.plot_metric(evals)\n",
    "        # lgb.plot_tree(model, figsize=(20, 8))\n",
    "        lgb.plot_importance(model, importance_type='split', max_num_features=20)\n",
    "        plt.show()\n",
    "    return model\n",
    "\n",
    "\n",
    "from catboost import CatBoostRegressor\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "def train_catboost(train_data_df, test_data_df, feature_columns, params=None, plot=False):\n",
    "\n",
    "    train_data_df, test_data_df = train_data_df.dropna(subset=['label']), test_data_df.dropna(subset=['label'])\n",
    "    X_train = train_data_df[feature_columns]\n",
    "    y_train = train_data_df['label']\n",
    "\n",
    "    X_val = test_data_df[feature_columns]\n",
    "    y_val = test_data_df['label']\n",
    "\n",
    "    cat_features = [i for i, col in enumerate(feature_columns) if col.startswith('cat')]\n",
    "    print(f'cat_features: {cat_features}')\n",
    "    train_pool = Pool(data=X_train, label=y_train, cat_features=cat_features)\n",
    "    val_pool = Pool(data=X_val, label=y_val, cat_features=cat_features)\n",
    "\n",
    "    model = CatBoostRegressor(**params)\n",
    "    model.fit(train_pool,\n",
    "              eval_set=[train_pool, val_pool])\n",
    "\n",
    "    return model"
   ],
   "outputs": [],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "id": "4a4542e1ed6afe7d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:40:36.799266Z",
     "start_time": "2025-02-23T15:40:36.714195Z"
    }
   },
   "source": [
    "light_params = {\n",
    "    'objective': 'regression',\n",
    "    'metric': 'l2',\n",
    "    # 'objective': 'quantile',  # 分位回归\n",
    "    # 'metric': 'quantile',  # 使用 quantile 作为评估指标\n",
    "    'alpha': 0.75,  # 90% 分位数\n",
    "    'learning_rate': 0.05,\n",
    "    'is_unbalance': True,\n",
    "    'num_leaves': 1024,\n",
    "    'min_data_in_leaf': 128,\n",
    "    'max_depth': 32,\n",
    "    'max_bin': 1024,\n",
    "    'feature_fraction': 0.7,\n",
    "    'bagging_fraction': 0.7,\n",
    "    'bagging_freq': 5,\n",
    "    'lambda_l1': 1,\n",
    "    'lambda_l2': 1,\n",
    "    # 'boosting_type': 'dart',\n",
    "    'verbosity': -1\n",
    "}"
   ],
   "outputs": [],
   "execution_count": 17
  },
  {
   "cell_type": "code",
   "id": "beeb098799ecfa6a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:41:02.591899Z",
     "start_time": "2025-02-23T15:40:36.877547Z"
    }
   },
   "source": [
    "print('train data size: ', len(train_data))\n",
    "\n",
    "evals = {}\n",
    "model = train_light_model(train_data, test_data, light_params, feature_columns_new,\n",
    "                                 [lgb.log_evaluation(period=500),\n",
    "                                  lgb.callback.record_evaluation(evals),\n",
    "                                  lgb.early_stopping(50, first_metric_only=True)\n",
    "                                  ], evals,\n",
    "                                 num_boost_round=500, use_optuna=False,\n",
    "                                 print_feature_importance=True)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train data size:  807303\n",
      "categorical_feature: [3, 35, 36, 37, 38]\n",
      "Training until validation scores don't improve for 50 rounds\n",
      "Early stopping, best iteration is:\n",
      "[24]\ttrain's l2: 0.00229628\tvalid's l2: 0.00252369\n",
      "Evaluated only: l2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "code",
   "id": "63235069-dc59-48fb-961a-e80373e41a61",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:41:02.758847Z",
     "start_time": "2025-02-23T15:41:02.670568Z"
    }
   },
   "source": [
    "print('train data size: ', len(train_data))\n",
    "\n",
    "catboost_params = {\n",
    "    'loss_function': 'MAE',  # 90% 分位回归\n",
    "    'iterations': 5000,          # 训练轮数\n",
    "    'learning_rate': 0.05,       # 学习率，较低以防止过拟合\n",
    "    'depth': 10,                  # 树的深度，防止过拟合\n",
    "    # 'l1_leaf_reg': 10.0,         # l1 正则化，提高泛化能力\n",
    "    # 'bagging_temperature': 1,    # 降低过拟合\n",
    "    # 'subsample': 0.8,            # 每轮随机 80% 的样本，减少过拟合\n",
    "    'colsample_bylevel': 0.8,    # 每层 80% 特征子集，防止过拟合\n",
    "    'random_seed': 42,           # 固定随机种子，保证可复现\n",
    "    'verbose': 500,              # 每 100 轮打印一次信息\n",
    "    'early_stopping_rounds': 100, # 早停，防止过拟合\n",
    "    # 'task_type': 'GPU'\n",
    "}\n",
    "\n",
    "# model = train_catboost(train_data, test_data, feature_columns_new, catboost_params)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train data size:  807303\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:41:02.928981Z",
     "start_time": "2025-02-23T15:41:02.836475Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "def incremental_training(test_data: pd.DataFrame,\n",
    "                         model,\n",
    "                         days: int,\n",
    "                         back_days: int,\n",
    "                         feature_columns: list,\n",
    "                         params: dict,\n",
    "                         model_type: str = 'lightgbm'):\n",
    "    if model_type not in ['lightgbm', 'catboost']:\n",
    "        raise ValueError(\"model_type must be either 'lightgbm' or 'catboost'\")\n",
    "\n",
    "    test_data = test_data.sort_values(by='trade_date')\n",
    "    scores = []\n",
    "    unique_trade_dates = sorted(test_data['trade_date'].unique())\n",
    "\n",
    "    new_model = None\n",
    "    for i in tqdm(range(0, len(unique_trade_dates), days)):\n",
    "        # Get the current window of trade dates\n",
    "        current_dates = unique_trade_dates[i:i + days]\n",
    "        window_data = test_data[test_data['trade_date'].isin(current_dates)]\n",
    "        X = window_data[feature_columns]\n",
    "\n",
    "        if new_model is not None:\n",
    "            window_scores = new_model.predict(X, prediction_type='RawFormulaVal')\n",
    "        else:\n",
    "            window_scores = model.predict(X, prediction_type='RawFormulaVal')\n",
    "        scores.extend(window_scores)\n",
    "\n",
    "        # Prepare data for incremental training\n",
    "        current_dates = unique_trade_dates[max(0, i - back_days):i + days]\n",
    "        window_data = test_data[test_data['trade_date'].isin(current_dates)]\n",
    "        X_train = window_data[feature_columns]\n",
    "        y_train = window_data['label']  # Assuming 'label' is what you're predicting\n",
    "        # Incrementally train the model\n",
    "        if len(y_train.unique()) > 1:\n",
    "            if model_type == 'lightgbm':\n",
    "                categorical_feature = [i for i, col in enumerate(feature_columns) if col.startswith('cat')]\n",
    "                train_data = lgb.Dataset(X_train, label=y_train, categorical_feature=categorical_feature)\n",
    "                new_model = lgb.train(params,\n",
    "                                  train_set=train_data,\n",
    "                                  num_boost_round=100,\n",
    "                                  init_model=model,\n",
    "                                  keep_training_booster=True)\n",
    "            elif model_type == 'catboost':\n",
    "                from catboost import Pool\n",
    "                train_data = Pool(data=X_train, label=y_train, cat_features=[col for col in feature_columns if col.startswith('cat')])\n",
    "                # model.set_params(**params)\n",
    "                model.fit(train_data, init_model=model)\n",
    "        else:\n",
    "            print(current_dates)\n",
    "\n",
    "    # Add the scores as a new 'score' column to the test_data\n",
    "    test_data['score'] = scores\n",
    "    return test_data"
   ],
   "id": "465944b1d463e4b1",
   "outputs": [],
   "execution_count": 20
  },
  {
   "cell_type": "code",
   "id": "7359f89064a124d2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:41:43.347794Z",
     "start_time": "2025-02-23T15:41:03.010181Z"
    }
   },
   "source": [
    "\n",
    "predictions_test = incremental_training(test_data, model, 5, 0, feature_columns_new, light_params, model_type='lightgbm')\n",
    "predictions_test = predictions_test.loc[predictions_test.groupby('trade_date')['score'].idxmax()]\n",
    "predictions_test[['trade_date', 'score', 'ts_code']].to_csv('predictions_test.tsv', index=False)\n"
   ],
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 101/101 [00:39<00:00,  2.53it/s]\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "cell_type": "code",
   "id": "b427ce41-9739-4e9e-bea8-5f2551fec5d7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-23T15:41:43.468762Z",
     "start_time": "2025-02-23T15:41:43.453009Z"
    }
   },
   "source": [],
   "outputs": [],
   "execution_count": null
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}