Files
NewStock/main/train/UpdateRegression.ipynb
2025-06-01 15:59:29 +08:00

1139 lines
214 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
{
"cells": [
{
"cell_type": "code",
"id": "79a7758178bafdd3",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:15:11.540909Z",
"start_time": "2025-02-23T16:15:11.424065Z"
}
},
"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": 81
},
{
"cell_type": "code",
"id": "a79cafb06a7e0e43",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:15:58.383324Z",
"start_time": "2025-02-23T16:15:11.540909Z"
}
},
"source": [
"from code.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": 82
},
{
"cell_type": "code",
"id": "f7a55c19-b7dc-4d2f-a478-cffab11690df",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:16:00.292129Z",
"start_time": "2025-02-23T16:15:58.487459Z"
}
},
"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": 83
},
{
"cell_type": "code",
"id": "4077d4449d406c86",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:16:00.546130Z",
"start_time": "2025-02-23T16:16:00.386519Z"
}
},
"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": 84
},
{
"cell_type": "code",
"id": "c4e9e1d31da6dba6",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:16:00.737530Z",
"start_time": "2025-02-23T16:16:00.642938Z"
}
},
"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": 85
},
{
"cell_type": "code",
"id": "a735bc02ceb4d872",
"metadata": {
"jupyter": {
"source_hidden": true
},
"ExecuteTime": {
"end_time": "2025-02-23T16:16:04.486357Z",
"start_time": "2025-02-23T16:16:00.946508Z"
}
},
"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": 86
},
{
"cell_type": "code",
"id": "53f86ddc0677a6d7",
"metadata": {
"scrolled": true,
"ExecuteTime": {
"end_time": "2025-02-23T16:16:04.581828Z",
"start_time": "2025-02-23T16:16:04.486357Z"
}
},
"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": 87
},
{
"cell_type": "code",
"id": "dbe2fd8021b9417f",
"metadata": {
"scrolled": true,
"ExecuteTime": {
"end_time": "2025-02-23T16:17:07.870387Z",
"start_time": "2025-02-23T16:16:04.675873Z"
}
},
"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": 88
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:17:08.379851Z",
"start_time": "2025-02-23T16:17:08.136804Z"
}
},
"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": 89
},
{
"cell_type": "code",
"id": "5f3d9aece75318cd",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:18:01.015229Z",
"start_time": "2025-02-23T16:17:08.523778Z"
}
},
"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'] = calculate_risk_adjusted_target(df)\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 130394 outliers.\n"
]
}
],
"execution_count": 90
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:18:01.247742Z",
"start_time": "2025-02-23T16:18:01.062461Z"
}
},
"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": 91
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:18:23.307764Z",
"start_time": "2025-02-23T16:18:01.350526Z"
}
},
"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",
"803458\n",
"最小日期: 2017-03-21\n",
"最大日期: 2022-12-30\n",
"295396\n",
"最小日期: 2023-01-03\n",
"最大日期: 2025-02-10\n"
]
}
],
"execution_count": 92
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:18:23.562209Z",
"start_time": "2025-02-23T16:18:23.402196Z"
}
},
"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": 93
},
{
"cell_type": "code",
"id": "8f134d435f71e9e2",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:18:23.750424Z",
"start_time": "2025-02-23T16:18:23.658374Z"
}
},
"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": 94
},
{
"cell_type": "code",
"id": "4a4542e1ed6afe7d",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:18:23.926397Z",
"start_time": "2025-02-23T16:18:23.845350Z"
}
},
"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": 95
},
{
"cell_type": "code",
"id": "beeb098799ecfa6a",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:19:00.337345Z",
"start_time": "2025-02-23T16:18:24.039383Z"
}
},
"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: 803458\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",
"[42]\ttrain's quantile: 0.00081298\tvalid's quantile: 0.000834099\n",
"Evaluated only: quantile\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": 96
},
{
"cell_type": "code",
"id": "63235069-dc59-48fb-961a-e80373e41a61",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:19:00.519302Z",
"start_time": "2025-02-23T16:19:00.431726Z"
}
},
"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: 803458\n"
]
}
],
"execution_count": 97
},
{
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:19:00.712334Z",
"start_time": "2025-02-23T16:19:00.629410Z"
}
},
"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",
" X_train = X\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": 98
},
{
"cell_type": "code",
"id": "7359f89064a124d2",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:19:43.822814Z",
"start_time": "2025-02-23T16:19:00.806697Z"
}
},
"source": [
"# future_close = test_data.groupby('ts_code')['close'].shift(-3)\n",
"# future_return = (future_close - df['close']) / df['close']\n",
"# test_data['label'] = future_return\n",
"# test_data['label'] = remove_outliers_label_percentile(df['label'])\n",
"\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:42<00:00, 2.37it/s]\n"
]
}
],
"execution_count": 99
},
{
"cell_type": "code",
"id": "b427ce41-9739-4e9e-bea8-5f2551fec5d7",
"metadata": {
"ExecuteTime": {
"end_time": "2025-02-23T16:19:43.950667Z",
"start_time": "2025-02-23T16:19:43.934996Z"
}
},
"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
}