{ "cells": [ { "cell_type": "code", "id": "79a7758178bafdd3", "metadata": { "jupyter": { "source_hidden": true }, "ExecuteTime": { "end_time": "2025-04-03T12:46:06.987506Z", "start_time": "2025-04-03T12:46:06.259551Z" } }, "source": [ "# %load_ext autoreload\n", "# %autoreload 2\n", "\n", "import pandas as pd\n", "import warnings\n", "\n", "warnings.filterwarnings(\"ignore\")\n", "\n", "pd.set_option('display.max_columns', None)\n" ], "outputs": [], "execution_count": 1 }, { "cell_type": "code", "id": "a79cafb06a7e0e43", "metadata": { "scrolled": true, "ExecuteTime": { "end_time": "2025-04-03T12:47:00.212859Z", "start_time": "2025-04-03T12:46:06.998047Z" } }, "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', 'pct_chg'],\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('cyq perf')\n", "df = read_and_merge_h5_data('../../data/cyq_perf.h5', key='cyq_perf',\n", " columns=['ts_code', 'trade_date', 'his_low', 'his_high', 'cost_5pct', 'cost_15pct',\n", " 'cost_50pct',\n", " 'cost_85pct', 'cost_95pct', 'weight_avg', 'winner_rate'],\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", "cyq perf\n", "left merge on ['ts_code', 'trade_date']\n", "\n", "RangeIndex: 8477357 entries, 0 to 8477356\n", "Data columns (total 31 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 pct_chg float64 \n", " 8 turnover_rate float64 \n", " 9 pe_ttm float64 \n", " 10 circ_mv float64 \n", " 11 volume_ratio float64 \n", " 12 is_st bool \n", " 13 up_limit float64 \n", " 14 down_limit float64 \n", " 15 buy_sm_vol float64 \n", " 16 sell_sm_vol float64 \n", " 17 buy_lg_vol float64 \n", " 18 sell_lg_vol float64 \n", " 19 buy_elg_vol float64 \n", " 20 sell_elg_vol float64 \n", " 21 net_mf_vol float64 \n", " 22 his_low float64 \n", " 23 his_high float64 \n", " 24 cost_5pct float64 \n", " 25 cost_15pct float64 \n", " 26 cost_50pct float64 \n", " 27 cost_85pct float64 \n", " 28 cost_95pct float64 \n", " 29 weight_avg float64 \n", " 30 winner_rate float64 \n", "dtypes: bool(1), datetime64[ns](1), float64(28), object(1)\n", "memory usage: 1.9+ GB\n", "None\n" ] } ], "execution_count": 2 }, { "cell_type": "code", "id": "cac01788dac10678", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T12:47:10.527104Z", "start_time": "2025-04-03T12:47:00.488715Z" } }, "source": [ "print('industry')\n", "industry_df = read_and_merge_h5_data('../../data/industry_data.h5', key='industry_data',\n", " columns=['ts_code', 'l2_code', 'in_date'],\n", " df=None, on=['ts_code'], join='left')\n", "\n", "\n", "def merge_with_industry_data(df, industry_df):\n", " # 确保日期字段是 datetime 类型\n", " df['trade_date'] = pd.to_datetime(df['trade_date'])\n", " industry_df['in_date'] = pd.to_datetime(industry_df['in_date'])\n", "\n", " # 对 industry_df 按 ts_code 和 in_date 排序\n", " industry_df_sorted = industry_df.sort_values(['in_date', 'ts_code'])\n", "\n", " # 对原始 df 按 ts_code 和 trade_date 排序\n", " df_sorted = df.sort_values(['trade_date', 'ts_code'])\n", "\n", " # 使用 merge_asof 进行向后合并\n", " merged = pd.merge_asof(\n", " df_sorted,\n", " industry_df_sorted,\n", " by='ts_code', # 按 ts_code 分组\n", " left_on='trade_date',\n", " right_on='in_date',\n", " direction='backward'\n", " )\n", "\n", " # 获取每个 ts_code 的最早 in_date 记录\n", " min_in_date_per_ts = (industry_df_sorted\n", " .groupby('ts_code')\n", " .first()\n", " .reset_index()[['ts_code', 'l2_code']])\n", "\n", " # 填充未匹配到的记录（trade_date 早于所有 in_date 的情况）\n", " merged['l2_code'] = merged['l2_code'].fillna(\n", " merged['ts_code'].map(min_in_date_per_ts.set_index('ts_code')['l2_code'])\n", " )\n", "\n", " # 保留需要的列并重置索引\n", " result = merged.reset_index(drop=True)\n", " return result\n", "\n", "\n", "# 使用示例\n", "df = merge_with_industry_data(df, industry_df)\n", "# print(mdf[mdf['ts_code'] == '600751.SH'][['ts_code', 'trade_date', 'l2_code']])" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "industry\n" ] } ], "execution_count": 3 }, { "cell_type": "code", "id": "c4e9e1d31da6dba6", "metadata": { "jupyter": { "source_hidden": true }, "ExecuteTime": { "end_time": "2025-04-03T12:47:10.719252Z", "start_time": "2025-04-03T12:47:10.541247Z" } }, "source": [ "def calculate_indicators(df):\n", " \"\"\"\n", " 计算四个指标：当日涨跌幅、5日移动平均、RSI、MACD。\n", " \"\"\"\n", " df = df.sort_values('trade_date')\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", " # 4. 情绪因子1：市场上涨比例（Up Ratio）\n", " df['up_ratio'] = df['daily_return'].apply(lambda x: 1 if x > 0 else 0)\n", " df['up_ratio_20d'] = df['up_ratio'].rolling(window=20).mean() # 过去20天上涨比例\n", "\n", " # 5. 情绪因子2：成交量变化率（Volume Change Rate）\n", " df['volume_mean'] = df['vol'].rolling(window=20).mean() # 过去20天的平均成交量\n", " df['volume_change_rate'] = (df['vol'] - df['volume_mean']) / df['volume_mean'] * 100 # 成交量变化率\n", "\n", " # 6. 情绪因子3：波动率（Volatility）\n", " df['volatility'] = df['daily_return'].rolling(window=20).std() # 过去20天的日收益率标准差\n", "\n", " # 7. 情绪因子4：成交额变化率（Amount Change Rate）\n", " df['amount_mean'] = df['amount'].rolling(window=20).mean() # 过去20天的平均成交额\n", " df['amount_change_rate'] = (df['amount'] - df['amount_mean']) / df['amount_mean'] * 100 # 成交额变化率\n", "\n", " return df\n", "\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',\n", " 'MACD_hist', 'up_ratio_20d', 'volume_change_rate', 'volatility',\n", " 'amount_change_rate', 'amount_mean'],\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": 4 }, { "cell_type": "code", "id": "a735bc02ceb4d872", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T12:47:10.821169Z", "start_time": "2025-04-03T12:47:10.751831Z" } }, "source": [ "import numpy as np\n", "import talib\n", "\n", "def get_rolling_factor(df):\n", " old_columns = df.columns.tolist()[:]\n", "\n", "\n", " # 按股票和日期排序（如果尚未排序）\n", " df = df.sort_values(by=['ts_code', 'trade_date'])\n", "\n", " grouped = df.groupby('ts_code', group_keys=False)\n", "\n", " # 提前计算布尔掩码\n", " window = 5\n", " return_threshold = 0.0\n", "\n", " df['_is_upside'] = df['pct_chg'] > return_threshold\n", " df['_is_downside'] = df['pct_chg'] < -return_threshold\n", " \n", " # 1. 上行波动率 (20日)\n", " def rolling_upside_volatility(series, _is_upside, window):\n", " # 提取正收益\n", " positive_returns = series.where(_is_upside, np.nan)\n", " # 计算滚动窗口标准差\n", " return positive_returns.rolling(window=window, min_periods=2).std()\n", " \n", " df[f'upside_volatility_{window}'] = grouped.apply(\n", " lambda x: rolling_upside_volatility(x['pct_chg'], x['_is_upside'], window)\n", " ).reset_index(level=0, drop=True)\n", " \n", " # 2. 下行波动率 (20日)\n", " def rolling_downside_volatility(series, _is_downside, window):\n", " # 提取负收益\n", " negative_returns = series.where(_is_downside, np.nan)\n", " # 计算滚动窗口标准差\n", " return negative_returns.rolling(window=window, min_periods=2).std()\n", " \n", " df[f'downside_volatility_{window}'] = grouped.apply(\n", " lambda x: rolling_downside_volatility(x['pct_chg'], x['_is_downside'], window)\n", " ).reset_index(level=0, drop=True)\n", " \n", " # 3. 上行/下行波动率比率 (20日)\n", " df[f'volatility_ratio_{window}'] = df[f'upside_volatility_{window}'] / (df[f'downside_volatility_{window}'] + 1e-8)\n", " \n", " # 4. 上行半方差 (20日)\n", " def rolling_upside_semi_variance(series, _is_upside, window, threshold):\n", " # 提取正收益\n", " positive_returns = series.where(_is_upside, np.nan)\n", " # 计算平方偏差\n", " squared_deviation = (positive_returns - threshold)**2\n", " # 计算滚动窗口均值\n", " return squared_deviation.rolling(window=window, min_periods=2).mean()\n", " \n", " df[f'upside_semi_variance_{window}'] = grouped.apply(\n", " lambda x: rolling_upside_semi_variance(x['pct_chg'], x['_is_upside'], window, return_threshold)\n", " ).reset_index(level=0, drop=True)\n", " \n", " # 5. 下行半方差 (20日)\n", " def rolling_downside_semi_variance(series, _is_downside, window, threshold):\n", " # 提取负收益\n", " negative_returns = series.where(_is_downside, np.nan)\n", " # 计算平方偏差\n", " squared_deviation = (negative_returns - (-threshold))**2\n", " # 计算滚动窗口均值\n", " return squared_deviation.rolling(window=window, min_periods=2).mean()\n", " \n", " df[f'downside_semi_variance_{window}'] = grouped.apply(\n", " lambda x: rolling_downside_semi_variance(x['pct_chg'], x['_is_downside'], window, return_threshold)\n", " ).reset_index(level=0, drop=True)\n", "\n", " # 8. 正负收益天数比率 (20日)\n", " df[f'positive_negative_days_ratio_{window}'] = grouped['pct_chg'].rolling(window=window, min_periods=2).apply(lambda x: np.sum(x > 0) / (np.sum(x < 0) + 1e-8)).reset_index(level=0, drop=True)\n", "\n", " # 9. 正收益幅度均值 (20日)\n", " def average_positive_return_magnitude(series):\n", " positive_returns = series[series > return_threshold]\n", " if positive_returns.empty:\n", " return 0\n", " return positive_returns.mean()\n", " df[f'avg_positive_return_magnitude_{window}'] = grouped['pct_chg'].rolling(window=window, min_periods=2).apply(average_positive_return_magnitude).reset_index(level=0, drop=True)\n", "\n", " # 10. 负收益幅度均值 (20日)\n", " def average_negative_return_magnitude(series):\n", " negative_returns = series[series < -return_threshold]\n", " if negative_returns.empty:\n", " return 0\n", " return np.abs(negative_returns.mean())\n", " df[f'avg_negative_return_magnitude_{window}'] = grouped['pct_chg'].rolling(window=window, min_periods=2).apply(average_negative_return_magnitude).reset_index(level=0, drop=True)\n", "\n", " # df[\"gap_next_open\"] = (df[\"open\"].shift(-1) - df[\"close\"]) / df[\"close\"]\n", "\n", " df['return_skew'] = grouped['pct_chg'].rolling(window=5).skew().reset_index(0, drop=True)\n", " df['return_kurtosis'] = grouped['pct_chg'].rolling(window=5).kurt().reset_index(0, drop=True)\n", "\n", " # 因子 1：短期成交量变化率\n", " df['volume_change_rate'] = (\n", " grouped['vol'].rolling(window=2).mean() /\n", " grouped['vol'].rolling(window=10).mean() - 1\n", " ).reset_index(level=0, drop=True) # 确保索引对齐\n", "\n", " # 因子 2：成交量突破信号\n", " max_volume = grouped['vol'].rolling(window=5).max().reset_index(level=0, drop=True) # 确保索引对齐\n", " df['cat_volume_breakout'] = (df['vol'] > max_volume)\n", "\n", " # 因子 3：换手率均线偏离度\n", " mean_turnover = grouped['turnover_rate'].rolling(window=3).mean().reset_index(level=0, drop=True)\n", " std_turnover = grouped['turnover_rate'].rolling(window=3).std().reset_index(level=0, drop=True)\n", " df['turnover_deviation'] = (df['turnover_rate'] - mean_turnover) / std_turnover\n", "\n", " # 因子 4：换手率激增信号\n", " df['cat_turnover_spike'] = (df['turnover_rate'] > mean_turnover + 2 * std_turnover)\n", "\n", " # 因子 5：量比均值\n", " df['avg_volume_ratio'] = grouped['volume_ratio'].rolling(window=3).mean().reset_index(level=0, drop=True)\n", "\n", " # 因子 6：量比突破信号\n", " max_volume_ratio = grouped['volume_ratio'].rolling(window=5).max().reset_index(level=0, drop=True)\n", " df['cat_volume_ratio_breakout'] = (df['volume_ratio'] > max_volume_ratio)\n", "\n", " df['vol_spike'] = grouped.apply(\n", " lambda x: pd.Series(x['vol'].rolling(20).mean(), index=x.index)\n", " )\n", " df['vol_std_5'] = df['vol'].pct_change().rolling(5).std()\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),\n", " 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),\n", " 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", "\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", " # 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", " # 计算 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", " # 根据 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", " df['log(circ_mv)'] = np.log(df['circ_mv'])\n", "\n", " def rolling_covariance(x, y, window):\n", " return x.rolling(window).cov(y)\n", "\n", " def delta(series, period):\n", " return series.diff(period)\n", "\n", " def rank(series):\n", " return series.rank(pct=True)\n", "\n", " def stddev(series, window):\n", " return series.rolling(window).std()\n", "\n", " window_high_volume = 5\n", " window_close_stddev = 20\n", " period_delta = 5\n", " df['cov'] = rolling_covariance(df['high'], df['vol'], window_high_volume)\n", " df['delta_cov'] = delta(df['cov'], period_delta)\n", " df['_rank_stddev'] = rank(stddev(df['close'], window_close_stddev))\n", " df['alpha_22_improved'] = -1 * df['delta_cov'] * df['_rank_stddev']\n", "\n", " df['alpha_003'] = np.where(df['high'] != df['low'],\n", " (df['close'] - df['open']) / (df['high'] - df['low']),\n", " 0)\n", "\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", " 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", " df['cat_up_limit'] = (df['close'] == df['up_limit']) # 是否涨停（1表示涨停，0表示未涨停）\n", " df['cat_down_limit'] = (df['close'] == df['down_limit']) # 是否跌停（1表示跌停，0表示未跌停）\n", " df['up_limit_count_10d'] = grouped['cat_up_limit'].rolling(window=10, min_periods=1).sum().reset_index(level=0,\n", " drop=True)\n", " df['down_limit_count_10d'] = grouped['cat_down_limit'].rolling(window=10, min_periods=1).sum().reset_index(level=0,\n", " drop=True)\n", "\n", " # 3. 最近连续涨跌停天数\n", " def calculate_consecutive_limits(series):\n", " \"\"\"\n", " 计算连续涨停/跌停天数。\n", " \"\"\"\n", " consecutive_up = series * (series.groupby((series != series.shift()).cumsum()).cumcount() + 1)\n", " consecutive_down = series * (series.groupby((series != series.shift()).cumsum()).cumcount() + 1)\n", " return consecutive_up, consecutive_down\n", "\n", " # 连续涨停天数\n", " df['consecutive_up_limit'] = grouped['cat_up_limit'].apply(\n", " lambda x: calculate_consecutive_limits(x)[0]\n", " ).reset_index(level=0, drop=True)\n", "\n", " df['vol_break'] = np.where((df['close'] > df['cost_85pct']) & (df['volume_ratio'] > 2), 1, 0)\n", "\n", " df['weight_roc5'] = grouped['weight_avg'].apply(lambda x: x.pct_change(5))\n", "\n", " def rolling_corr(group):\n", " roc_close = group['close'].pct_change()\n", " roc_weight = group['weight_avg'].pct_change()\n", " return roc_close.rolling(10).corr(roc_weight)\n", "\n", " df['price_cost_divergence'] = grouped.apply(rolling_corr)\n", "\n", " df['smallcap_concentration'] = (1 / df['log(circ_mv)']) * (df['cost_85pct'] - df['cost_15pct'])\n", "\n", " # 16. 筹码稳定性指数 (20日波动率)\n", " df['weight_std20'] = grouped['weight_avg'].apply(lambda x: x.rolling(20).std())\n", " df['cost_stability'] = df['weight_std20'] / grouped['weight_avg'].transform(lambda x: x.rolling(20).mean())\n", "\n", " # 17. 成本区间突破标记\n", " df['high_cost_break_days'] = grouped.apply(lambda g: g['close'].gt(g['cost_95pct']).rolling(5).sum())\n", "\n", " # 20. 筹码-流动性风险\n", " df['liquidity_risk'] = (df['cost_95pct'] - df['cost_5pct']) * (\n", " 1 / grouped['vol'].transform(lambda x: x.rolling(10).mean()))\n", "\n", " # 7. 市值波动率因子\n", " df['turnover_std'] = grouped['turnover_rate'].rolling(window=20).std().reset_index(level=0, drop=True)\n", " df['mv_volatility'] = grouped.apply(lambda x: x['turnover_std'] / x['log(circ_mv)']).reset_index(level=0, drop=True)\n", "\n", " # 8. 市值成长性因子\n", " df['volume_growth'] = grouped['vol'].pct_change(periods=20).reset_index(level=0, drop=True)\n", " df['mv_growth'] = grouped.apply(lambda x: x['volume_growth'] / x['log(circ_mv)']).reset_index(level=0, drop=True)\n", "\n", " df[\"ar\"] = df[\"high\"].div(df[\"open\"]).rolling(3).sum() / df[\"open\"].div(df[\"low\"]).rolling(3).sum() * 100\n", " # 计算 BR 指标\n", " df[\"pre_close\"] = df[\"close\"].shift(1)\n", " df[\"br_up\"] = (df[\"high\"] - df[\"pre_close\"]).clip(lower=0)\n", " df[\"br_down\"] = (df[\"pre_close\"] - df[\"low\"]).clip(lower=0)\n", " df[\"br\"] = df[\"br_up\"].rolling(3).sum() / df[\"br_down\"].rolling(3).sum() * 100\n", " df['arbr'] = df['ar'] - df['br']\n", " df.drop(columns=[\"pre_close\", \"br_up\", \"br_down\", 'ar', 'br'], inplace=True)\n", "\n", " df.drop(columns=['weight_std20'], inplace=True, errors='ignore')\n", " new_columns = [col for col in df.columns.tolist()[:] if col not in old_columns]\n", "\n", " return df, new_columns\n", "\n", "\n", "def get_simple_factor(df):\n", " old_columns = df.columns.tolist()[:]\n", " df = df.sort_values(by=['ts_code', 'trade_date'])\n", "\n", " alpha = 0.5\n", " df['momentum_factor'] = df['volume_change_rate'] + alpha * df['turnover_deviation']\n", " df['resonance_factor'] = df['volume_ratio'] * df['pct_chg']\n", " df['log_close'] = np.log(df['close'])\n", "\n", " df['cat_vol_spike'] = df['vol'] > 2 * df['vol_spike']\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", " df['obv-maobv_6'] = df['obv'] - df['maobv_6']\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", " # 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(\n", " df['act_factor1'] ** 2 + df['act_factor2'] ** 2)\n", "\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", "\n", " df['ctrl_strength'] = (df['cost_85pct'] - df['cost_15pct']) / (df['his_high'] - df['his_low'])\n", "\n", " df['low_cost_dev'] = (df['close'] - df['cost_5pct']) / (df['cost_50pct'] - df['cost_5pct'])\n", "\n", " df['asymmetry'] = (df['cost_95pct'] - df['cost_50pct']) / (df['cost_50pct'] - df['cost_5pct'])\n", "\n", " df['lock_factor'] = df['turnover_rate'] * (\n", " 1 - (df['cost_95pct'] - df['cost_5pct']) / (df['his_high'] - df['his_low']))\n", "\n", " df['cat_vol_break'] = (df['close'] > df['cost_85pct']) & (df['volume_ratio'] > 2)\n", "\n", " df['cost_atr_adj'] = (df['cost_95pct'] - df['cost_5pct']) / df['atr_14']\n", "\n", " # 12. 小盘股筹码集中度\n", " df['smallcap_concentration'] = (1 / df['log(circ_mv)']) * (df['cost_85pct'] - df['cost_15pct'])\n", "\n", " df['cat_golden_resonance'] = ((df['close'] > df['weight_avg']) &\n", " (df['volume_ratio'] > 1.5) &\n", " (df['winner_rate'] > 0.7))\n", "\n", " df['mv_turnover_ratio'] = df['turnover_rate'] / df['log(circ_mv)']\n", "\n", " df['mv_adjusted_volume'] = df['vol'] / df['log(circ_mv)']\n", "\n", " df['mv_weighted_turnover'] = df['turnover_rate'] * (1 / df['log(circ_mv)'])\n", "\n", " df['nonlinear_mv_volume'] = df['vol'] / df['log(circ_mv)']\n", "\n", " df['mv_volume_ratio'] = df['volume_ratio'] / df['log(circ_mv)']\n", "\n", " df['mv_momentum'] = df['turnover_rate'] * df['volume_ratio'] / df['log(circ_mv)']\n", "\n", " drop_columns = [col for col in df.columns if col.startswith('_')]\n", " df.drop(columns=drop_columns, inplace=True, errors='ignore')\n", "\n", " new_columns = [col for col in df.columns.tolist()[:] if col not in old_columns]\n", " return df, new_columns\n" ], "outputs": [], "execution_count": 5 }, { "cell_type": "code", "id": "53f86ddc0677a6d7", "metadata": { "jupyter": { "source_hidden": true }, "scrolled": true, "ExecuteTime": { "end_time": "2025-04-03T12:47:15.944254Z", "start_time": "2025-04-03T12:47:10.826179Z" } }, "source": [ "from utils.factor import get_act_factor\n", "\n", "\n", "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.sort_values(by=['ts_code', 'trade_date'])\n", " industry_data = industry_data.reindex()\n", " industry_data['trade_date'] = pd.to_datetime(industry_data['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(\n", " # lambda x: x - x.mean())\n", "\n", " industry_data['return_5_percentile'] = industry_data.groupby('trade_date')['return_5'].transform(\n", " lambda x: x.rank(pct=True))\n", " industry_data['return_20_percentile'] = industry_data.groupby('trade_date')['return_20'].transform(\n", " lambda x: x.rank(pct=True))\n", " industry_data = industry_data.drop(columns=['open', 'close', 'high', 'low', 'pe', 'pb', 'vol'])\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", "\n", "industry_df = read_industry_data('../../data/sw_daily.h5')\n" ], "outputs": [], "execution_count": 6 }, { "cell_type": "code", "id": "dbe2fd8021b9417f", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T12:47:15.969344Z", "start_time": "2025-04-03T12:47:15.963327Z" } }, "source": [ "origin_columns = df.columns.tolist()\n", "origin_columns = [col for col in origin_columns if\n", " col not in ['turnover_rate', 'pe_ttm', 'volume_ratio', 'vol', 'pct_chg', 'l2_code', 'winner_rate']]\n", "origin_columns = [col for col in origin_columns if col not in index_data.columns]\n", "origin_columns = [col for col in origin_columns if 'cyq' not in col]\n", "print(origin_columns)" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['ts_code', 'open', 'close', 'high', 'low', 'circ_mv', 'is_st', 'up_limit', 'down_limit', 'buy_sm_vol', 'sell_sm_vol', 'buy_lg_vol', 'sell_lg_vol', 'buy_elg_vol', 'sell_elg_vol', 'net_mf_vol', 'his_low', 'his_high', 'cost_5pct', 'cost_15pct', 'cost_50pct', 'cost_85pct', 'cost_95pct', 'weight_avg', 'in_date']\n" ] } ], "execution_count": 7 }, { "cell_type": "code", "id": "85c3e3d0235ffffa", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T12:47:16.089879Z", "start_time": "2025-04-03T12:47:15.990101Z" } }, "source": [ "print(df[df['is_st']][['ts_code', 'trade_date', 'is_st']])" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " ts_code trade_date is_st\n", "29 000037.SZ 2017-01-03 True\n", "72 000408.SZ 2017-01-03 True\n", "95 000504.SZ 2017-01-03 True\n", "96 000505.SZ 2017-01-03 True\n", "101 000511.SZ 2017-01-03 True\n", "... ... ... ...\n", "8476334 603869.SH 2025-03-28 True\n", "8476339 603879.SH 2025-03-28 True\n", "8476386 603959.SH 2025-03-28 True\n", "8476769 688282.SH 2025-03-28 True\n", "8476773 688287.SH 2025-03-28 True\n", "\n", "[192712 rows x 3 columns]\n" ] } ], "execution_count": 8 }, { "cell_type": "code", "id": "92d84ce15a562ec6", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T13:08:01.612695Z", "start_time": "2025-04-03T12:47:16.121802Z" } }, "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[df['trade_date'] >= '20180101']\n", " if 'in_date' in df.columns:\n", " df = df.drop(columns=['in_date'])\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 = get_limit_factor(df)\n", "# df = get_cyp_perf_factor(df)\n", "# df = get_mv_factors(df)\n", "df, _ = get_rolling_factor(df)\n", "df, _ = get_simple_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": [ "\n", "Index: 5118212 entries, 0 to 5118211\n", "Columns: 123 entries, ts_code to mv_momentum\n", "dtypes: bool(12), datetime64[ns](1), float64(106), int32(1), int64(1), object(2)\n", "memory usage: 4.3+ GB\n", "None\n" ] } ], "execution_count": 9 }, { "cell_type": "code", "id": "b87b938028afa206", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T13:08:03.658725Z", "start_time": "2025-04-03T13:08:02.469611Z" } }, "source": [ "from scipy.stats import ks_2samp, wasserstein_distance\n", "\n", "\n", "def remove_shifted_features(train_data, test_data, feature_columns, ks_threshold=0.05, wasserstein_threshold=0.1,\n", " importance_threshold=0.05):\n", " dropped_features = []\n", "\n", " # **统计数据漂移**\n", " numeric_columns = train_data.select_dtypes(include=['float64', 'int64']).columns\n", " numeric_columns = [col for col in numeric_columns if col in feature_columns]\n", " for feature in numeric_columns:\n", " ks_stat, p_value = ks_2samp(train_data[feature], test_data[feature])\n", " wasserstein_dist = wasserstein_distance(train_data[feature], test_data[feature])\n", "\n", " if p_value < ks_threshold or wasserstein_dist > wasserstein_threshold:\n", " dropped_features.append(feature)\n", "\n", " print(f\"检测到 {len(dropped_features)} 个可能漂移的特征: {dropped_features}\")\n", "\n", " # **应用阈值进行最终筛选**\n", " filtered_features = [f for f in feature_columns if f not in dropped_features]\n", "\n", " return filtered_features, dropped_features\n", "\n" ], "outputs": [], "execution_count": 10 }, { "cell_type": "code", "id": "f4f16d63ad18d1bc", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T13:08:03.670700Z", "start_time": "2025-04-03T13:08:03.665739Z" } }, "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", "\n", " # num_features = ['vol', 'pct_chg', 'turnover_rate', 'volume_ratio', 'cat_vol_spike', 'obv', 'maobv_6', 'return_5', 'return_10', 'return_20', 'std_return_5', 'std_return_15', 'std_return_90', 'std_return_90_2', 'act_factor1', 'act_factor2', 'act_factor3', 'act_factor4', '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', 'alpha_022', 'alpha_003', 'alpha_007', 'alpha_013']\n", " num_features = [col for col in num_features if 'cat' not in col and 'industry' not in col]\n", " num_features = [col for col in num_features if 'limit' not in col]\n", " num_features = [col for col in num_features if 'cyq' not in col]\n", "\n", " # 遍历所有数值型特征\n", " for feature in num_features:\n", " if feature == 'trade_date': # 不需要对 'trade_date' 计算偏差\n", " continue\n", "\n", " # grouped_mean = df.groupby(['trade_date'])[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", " grouped_mean = df.groupby(['trade_date', 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" ], "outputs": [], "execution_count": 11 }, { "cell_type": "code", "id": "40e6b68a91b30c79", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T13:08:04.694262Z", "start_time": "2025-04-03T13:08:03.694904Z" } }, "source": [ "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", " log=True):\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", " if log:\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_open'] = df.groupby('ts_code')['open'].shift(-1)\n", " df['future_return'] = (df['future_close'] - df['future_open']) / df['future_open']\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", " sharpe_ratio = df['future_return'] * df['future_volatility']\n", " sharpe_ratio.replace([np.inf, -np.inf], np.nan, inplace=True)\n", "\n", " return sharpe_ratio\n", "\n", "\n", "def calculate_score(df, days=5, lambda_param=1.0):\n", " def calculate_max_drawdown(prices):\n", " peak = prices.iloc[0] # 初始化峰值\n", " max_drawdown = 0 # 初始化最大回撤\n", "\n", " for price in prices:\n", " if price > peak:\n", " peak = price # 更新峰值\n", " else:\n", " drawdown = (peak - price) / peak # 计算当前回撤\n", " max_drawdown = max(max_drawdown, drawdown) # 更新最大回撤\n", "\n", " return max_drawdown\n", "\n", " def compute_stock_score(stock_df):\n", " stock_df = stock_df.sort_values(by=['trade_date'])\n", " future_return = stock_df['future_return']\n", " # 使用已有的 pct_chg 字段计算波动率\n", " volatility = stock_df['pct_chg'].rolling(days).std().shift(-days)\n", " max_drawdown = stock_df['close'].rolling(days).apply(calculate_max_drawdown, raw=False).shift(-days)\n", " score = future_return - lambda_param * max_drawdown\n", " return score\n", "\n", " # # 确保 DataFrame 按照股票代码和交易日期排序\n", " # df = df.sort_values(by=['ts_code', 'trade_date'])\n", "\n", " # 对每个股票分别计算 score\n", " df['score'] = df.groupby('ts_code').apply(compute_stock_score).reset_index(level=0, drop=True)\n", "\n", " return df['score']\n", "\n", "\n", "def remove_highly_correlated_features(df, feature_columns, threshold=0.9):\n", " numeric_features = df[feature_columns].select_dtypes(include=[np.number]).columns.tolist()\n", " if not numeric_features:\n", " raise ValueError(\"No numeric features found in the provided data.\")\n", "\n", " corr_matrix = df[numeric_features].corr().abs()\n", " upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))\n", " to_drop = [column for column in upper.columns if any(upper[column] > threshold)]\n", " remaining_features = [col for col in feature_columns if col not in to_drop\n", " or 'act' in col or 'af' in col]\n", " return remaining_features\n", "\n", "\n", "import pandas as pd\n", "from sklearn.preprocessing import StandardScaler\n", "\n", "\n", "def cross_sectional_standardization(df, features):\n", " df_sorted = df.sort_values(by='trade_date') # 按时间排序\n", " df_standardized = df_sorted.copy()\n", "\n", " for date in df_sorted['trade_date'].unique():\n", " # 获取当前时间点的数据\n", " current_data = df_standardized[df_standardized['trade_date'] == date]\n", "\n", " # 只对指定特征进行标准化\n", " scaler = StandardScaler()\n", " standardized_values = scaler.fit_transform(current_data[features])\n", "\n", " # 将标准化结果重新赋值回去\n", " df_standardized.loc[df_standardized['trade_date'] == date, features] = standardized_values\n", "\n", " return df_standardized\n", "\n", "\n", "import numpy as np\n", "import pandas as pd\n", "import statsmodels.api as sm\n", "\n", "from concurrent.futures import ProcessPoolExecutor\n", "\n", "\n", "def neutralize_manual(df, features, industry_col, mkt_cap_col):\n", " \"\"\" 手动实现简单回归以提升速度 \"\"\"\n", "\n", " for col in features:\n", " residuals = []\n", " for _, group in df.groupby(industry_col):\n", " if len(group) > 1:\n", " x = np.log(group[mkt_cap_col]) # 市值对数\n", " y = group[col] # 因子值\n", " beta = np.cov(y, x)[0, 1] / np.var(x) # 计算斜率\n", " alpha = np.mean(y) - beta * np.mean(x) # 计算截距\n", " resid = y - (alpha + beta * x) # 计算残差\n", " residuals.extend(resid)\n", " else:\n", " residuals.extend(group[col]) # 样本不足时保留原值\n", "\n", " df[col] = residuals\n", "\n", " return df\n", "\n", "\n", "import gc\n", "\n", "gc.collect()\n", "\n", "\n", "def mad_filter(df, features, n=3):\n", " for col in features:\n", " median = df[col].median()\n", " mad = np.median(np.abs(df[col] - median))\n", " upper = median + n * mad\n", " lower = median - n * mad\n", " df[col] = np.clip(df[col], lower, upper) # 截断极值\n", " return df\n", "\n", "\n", "def percentile_filter(df, features, lower_percentile=0.01, upper_percentile=0.99):\n", " for col in features:\n", " # 按日期分组计算上下百分位数\n", " lower_bound = df.groupby('trade_date')[col].transform(\n", " lambda x: x.quantile(lower_percentile)\n", " )\n", " upper_bound = df.groupby('trade_date')[col].transform(\n", " lambda x: x.quantile(upper_percentile)\n", " )\n", " # 截断超出范围的值\n", " df[col] = np.clip(df[col], lower_bound, upper_bound)\n", " return df\n", "\n", "\n", "from scipy.stats import iqr\n", "\n", "\n", "def iqr_filter(df, features):\n", " for col in features:\n", " df[col] = df.groupby('trade_date')[col].transform(\n", " lambda x: (x - x.median()) / iqr(x) if iqr(x) != 0 else x\n", " )\n", " return df\n", "\n", "\n", "def quantile_filter(df, features, lower_quantile=0.01, upper_quantile=0.99, window=60):\n", " df = df.copy()\n", " for col in features:\n", " # 计算 rolling 统计量，需要按日期进行 groupby\n", " rolling_lower = df.groupby('trade_date')[col].transform(lambda x: x.rolling(window=min(len(x), window)).quantile(lower_quantile))\n", " rolling_upper = df.groupby('trade_date')[col].transform(lambda x: x.rolling(window=min(len(x), window)).quantile(upper_quantile))\n", "\n", " # 对数据进行裁剪\n", " df[col] = np.clip(df[col], rolling_lower, rolling_upper)\n", " \n", " return df\n" ], "outputs": [], "execution_count": 12 }, { "cell_type": "code", "id": "47c12bb34062ae7a", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T14:57:50.841165Z", "start_time": "2025-04-03T14:49:25.889057Z" } }, "source": [ "days = 2\n", "validation_days = 120\n", "\n", "import gc\n", "\n", "gc.collect()\n", "\n", "df = df.sort_values(by=['ts_code', 'trade_date'])\n", "# df['future_return'] = df.groupby('ts_code', group_keys=False)['close'].apply(lambda x: x.shift(-days) / x - 1)\n", "df['future_return'] = (df.groupby('ts_code')['close'].shift(-days) - df.groupby('ts_code')['open'].shift(-1)) / \\\n", " df.groupby('ts_code')['open'].shift(-1)\n", "df['future_volatility'] = (\n", " df.groupby('ts_code')['pct_chg']\n", " .transform(lambda x: x.rolling(days).std().shift(-days))\n", ")\n", "\n", "# df['future_score'] = (\n", "# 0.7 * df['future_return']\n", "# * 0.3 * df['future_volatility']\n", "# )\n", "df['future_score'] = calculate_score(df, days=2, lambda_param=0.3)\n", "\n", "filter_index = df['future_return'].between(df['future_return'].quantile(0.01), df['future_return'].quantile(0.99))\n", "filter_index = df['future_volatility'].between(df['future_volatility'].quantile(0.01),\n", " df['future_volatility'].quantile(0.99)) | filter_index\n", "\n", "# df['label'] = df.groupby('trade_date', group_keys=False)['future_volatility'].transform(\n", "# lambda x: pd.qcut(x, q=30, labels=False, duplicates='drop')\n", "# )\n", "\n", "df['label'] = df.groupby('trade_date', group_keys=False)['future_score'].transform(\n", " lambda x: pd.qcut(x, q=20, labels=False, duplicates='drop')\n", ")\n", "\n", "\n", "# df['1_score'] = df.groupby('ts_code', group_keys=False)['future_score'].shift(days)\n", "# df['2_score'] = df.groupby('ts_code', group_keys=False)['future_score'].shift(1 + days)\n", "# df['3_score'] = df.groupby('ts_code', group_keys=False)['future_score'].shift(3 + days - 1)\n", "\n", "def symmetric_log_transform(values):\n", " return np.sign(values) * np.log1p(np.abs(values))\n", "\n", "\n", "train_data = df[filter_index & (df['trade_date'] <= '2023-08-01') & (df['trade_date'] >= '2000-01-01')]\n", "test_data = df[(df['trade_date'] >= '2023-08-01')]\n", "\n", "\n", "def select_pre_zt_stocks_dynamic(stock_df):\n", " # 排序数据\n", " stock_df = stock_df.sort_values(by=['trade_date', 'ts_code'])\n", " stock_df = stock_df.groupby('trade_date', group_keys=False).apply(\n", " lambda x: x.nlargest(1000, 'return_20')\n", " )\n", "\n", " return stock_df\n", "\n", "\n", "train_data = select_pre_zt_stocks_dynamic(train_data)\n", "test_data = select_pre_zt_stocks_dynamic(test_data)\n", "\n", "train_data, _ = get_simple_factor(train_data)\n", "test_data, _ = get_simple_factor(test_data)\n", "\n", "# train_data['label'] = train_data.groupby('trade_date', group_keys=False)['future_score'].transform(\n", "# lambda x: pd.qcut(x, q=50, labels=False, duplicates='drop')\n", "# )\n", "# test_data['label'] = test_data.groupby('trade_date', group_keys=False)['future_score'].transform(\n", "# lambda x: pd.qcut(x, q=50, labels=False, duplicates='drop')\n", "# )\n", "\n", "industry_df = industry_df.sort_values(by=['trade_date'])\n", "index_data = index_data.sort_values(by=['trade_date'])\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, test_data = train_data.replace([np.inf, -np.inf], np.nan), test_data.replace([np.inf, -np.inf], np.nan)\n", "\n", "# feature_columns_new = feature_columns[:]\n", "# train_data, _ = create_deviation_within_dates(train_data, feature_columns)\n", "# test_data, _ = create_deviation_within_dates(test_data, feature_columns)\n", "\n", "feature_columns = [col for col in train_data.columns if col in train_data.columns]\n", "feature_columns = [col for col in feature_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 'label' 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 'gen' not in col]\n", "feature_columns = [col for col in feature_columns if 'cat_l2_code' 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(f'feature_columns size: {len(feature_columns)}')\n", "\n", "numeric_columns = train_data.select_dtypes(include=['float64', 'int64']).columns\n", "numeric_columns = [col for col in numeric_columns if col in feature_columns]\n", "print('去极值')\n", "train_data = quantile_filter(train_data, numeric_columns) # 去极值\n", "# print('中性化')\n", "# train_data = neutralize_manual(train_data, numeric_columns, industry_col='cat_l2_code', mkt_cap_col='log(circ_mv)') # 中性化\n", "print('去极值')\n", "test_data = quantile_filter(test_data, numeric_columns) # 去极值\n", "# print('中性化')\n", "# test_data = neutralize_manual(test_data, numeric_columns, industry_col='cat_l2_code', mkt_cap_col='log(circ_mv)')\n", "all_dates = train_data['trade_date'].unique() # 获取所有唯一的 trade_date\n", "split_date = all_dates[-validation_days] # 划分点为倒数第 validation_days 天\n", "train_data_split = train_data[train_data['trade_date'] < split_date] # 训练集\n", "val_data_split = train_data[train_data['trade_date'] >= split_date] # 验证集\n", "\n", "feature_columns, _ = remove_shifted_features(\n", " train_data_split,\n", " val_data_split,\n", " feature_columns)\n", "\n", "feature_columns = remove_highly_correlated_features(train_data,\n", " feature_columns)\n", "keep_columns = [col for col in train_data.columns if\n", " col in feature_columns or col in ['ts_code', 'trade_date', 'label', 'future_return',\n", " 'future_score', 'future_volatility']]\n", "# train_data = train_data[keep_columns]\n", "print(f'feature_columns: {feature_columns}')\n", "\n", "train_data = train_data.dropna(subset=feature_columns)\n", "train_data = train_data.dropna(subset=['label'])\n", "train_data = train_data.reset_index(drop=True)\n", "\n", "# print(test_data.tail())\n", "test_data = test_data.dropna(subset=feature_columns)\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')}\")\n", "\n", "cat_columns = [col for col in feature_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')\n", "\n", "\n", "\n", "# feature_columns_new.remove('cat_l2_code')" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "feature_columns size: 114\n", "去极值\n", "去极值\n", "检测到 13 个可能漂移的特征: ['vol', 'pct_chg', 'turnover_rate', 'obv', 'log(circ_mv)', 'alpha_003', 'log_close', 'up', 'down', 'mv_turnover_ratio', 'mv_adjusted_volume', 'mv_weighted_turnover', 'nonlinear_mv_volume']\n", "feature_columns: ['pe_ttm', 'volume_ratio', 'winner_rate', 'upside_volatility_5', 'downside_volatility_5', 'volatility_ratio_5', 'upside_semi_variance_5', 'downside_semi_variance_5', 'positive_negative_days_ratio_5', 'avg_positive_return_magnitude_5', 'avg_negative_return_magnitude_5', 'return_skew', 'return_kurtosis', 'volume_change_rate', 'cat_volume_breakout', 'turnover_deviation', 'cat_turnover_spike', 'avg_volume_ratio', 'cat_volume_ratio_breakout', 'vol_spike', 'vol_std_5', 'atr_14', 'maobv_6', 'rsi_3', 'return_5', 'return_20', 'std_return_5', 'std_return_90', 'act_factor1', 'act_factor2', 'act_factor3', 'act_factor4', 'rank_act_factor1', 'rank_act_factor2', 'rank_act_factor3', 'cov', 'delta_cov', 'alpha_007', 'alpha_013', 'cat_up_limit', 'cat_down_limit', 'up_limit_count_10d', 'down_limit_count_10d', 'consecutive_up_limit', 'vol_break', 'weight_roc5', 'smallcap_concentration', 'cost_stability', 'high_cost_break_days', 'liquidity_risk', 'turnover_std', 'mv_volatility', 'volume_growth', 'mv_growth', 'arbr', 'momentum_factor', 'resonance_factor', 'cat_vol_spike', 'obv-maobv_6', 'std_return_5 / std_return_90', 'std_return_90 - std_return_90_2', 'cat_af2', 'cat_af3', 'cat_af4', 'act_factor5', 'act_factor6', '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', 'ctrl_strength', 'low_cost_dev', 'asymmetry', 'lock_factor', 'cat_vol_break', 'cost_atr_adj', 'cat_golden_resonance', 'mv_momentum', 'industry_obv', 'industry_return_5', 'industry_return_20', 'industry__ema_5', 'industry_act_factor1', 'industry_act_factor2', 'industry_act_factor3', 'industry_act_factor4', 'industry_act_factor5', 'industry_act_factor6', 'industry_rank_act_factor1', 'industry_rank_act_factor2', 'industry_rank_act_factor3', 'industry_return_5_percentile', 'industry_return_20_percentile']\n", "590201\n", "最小日期: 2018-06-04\n", "最大日期: 2023-08-01\n", "179005\n", "最小日期: 2023-08-01\n", "最大日期: 2025-03-28\n" ] } ], "execution_count": 55 }, { "cell_type": "code", "id": "8f134d435f71e9e2", "metadata": { "jupyter": { "source_hidden": true }, "ExecuteTime": { "end_time": "2025-04-03T14:57:51.050696Z", "start_time": "2025-04-03T14:57:51.034030Z" } }, "source": [ "from sklearn.preprocessing import StandardScaler\n", "import lightgbm as lgb\n", "import matplotlib.pyplot as plt\n", "from sklearn.decomposition import PCA\n", "\n", "\n", "def train_light_model(train_data_df, params, feature_columns, callbacks, evals,\n", " print_feature_importance=True, num_boost_round=100,\n", " validation_days=180, use_pca=False, split_date=None): # 新增参数：validation_days\n", " # 确保数据按时间排序\n", " train_data_df = train_data_df.sort_values(by='trade_date')\n", "\n", " numeric_columns = train_data_df.select_dtypes(include=['float64', 'int64']).columns\n", " numeric_columns = [col for col in numeric_columns if col in feature_columns]\n", " # X_train.loc[:, numeric_columns] = scaler.fit_transform(X_train[numeric_columns])\n", " # X_val.loc[:, numeric_columns] = scaler.transform(X_val[numeric_columns])\n", " train_data_df = cross_sectional_standardization(train_data_df, numeric_columns)\n", "\n", " # 去除标签为空的样本\n", " train_data_df = train_data_df.dropna(subset=['label'])\n", " print('原始训练集大小: ', len(train_data_df))\n", "\n", " # 按时间顺序划分训练集和验证集\n", " if split_date is None:\n", " all_dates = train_data_df['trade_date'].unique() # 获取所有唯一的 trade_date\n", " split_date = all_dates[-validation_days] # 划分点为倒数第 validation_days 天\n", " train_data_split = train_data_df[train_data_df['trade_date'] < split_date] # 训练集\n", " val_data_split = train_data_df[train_data_df['trade_date'] >= split_date] # 验证集\n", "\n", " # 打印划分结果\n", " print(f\"划分后的训练集大小: {len(train_data_split)}, 验证集大小: {len(val_data_split)}\")\n", "\n", " # 提取特征和标签\n", " X_train = train_data_split[feature_columns]\n", " y_train = train_data_split['label']\n", "\n", " X_val = val_data_split[feature_columns]\n", " y_val = val_data_split['label']\n", "\n", " # 标准化数值特征\n", " scaler = StandardScaler()\n", "\n", " # 计算每个 trade_date 内的样本数（LTR 需要 group 信息）\n", " train_groups = train_data_split.groupby('trade_date').size().tolist()\n", " val_groups = val_data_split.groupby('trade_date').size().tolist()\n", "\n", " # 处理类别特征\n", " categorical_feature = [col for col in feature_columns if 'cat' in col]\n", "\n", " pca = None\n", " if use_pca:\n", " pca = PCA(n_components=0.95) # 或指定 n_components=固定值（如 10）\n", " numeric_features = [col for col in feature_columns if col not in categorical_feature]\n", " numeric_pca = pca.fit_transform(X_train[numeric_features])\n", " X_train = pd.concat([pd.DataFrame(numeric_pca, index=X_train.index), X_train[categorical_feature]], axis=1)\n", "\n", " numeric_pca = pca.transform(X_val[numeric_features])\n", " X_val = pd.concat([pd.DataFrame(numeric_pca, index=X_val.index), X_val[categorical_feature]], axis=1)\n", "\n", " # 计算权重（基于时间）\n", " # trade_date = train_data_split['trade_date'] # 交易日期\n", " # weights = (trade_date - trade_date.min()).dt.days / (trade_date.max() - trade_date.min()).days + 1\n", " # weights = train_data_split.groupby('trade_date')['std_return_5'].transform(\n", " # lambda x: x / x.mean()\n", " # )\n", " ud = sorted(train_data_split[\"trade_date\"].unique().tolist())\n", " date_weights = {date: weight * weight for date, weight in zip(ud, np.linspace(1, 10, len(ud)))}\n", " params['weight'] = train_data_split[\"trade_date\"].map(date_weights).tolist()\n", "\n", " print('feature_columns size: ', len(X_train.columns.tolist()))\n", "\n", " train_dataset = lgb.Dataset(\n", " X_train, label=y_train, group=train_groups,\n", " categorical_feature=categorical_feature\n", " )\n", "\n", " # weights = val_data_split.groupby('trade_date')['std_return_5'].transform(\n", " # lambda x: x / x.mean()\n", " # )\n", " val_dataset = lgb.Dataset(\n", " X_val, label=y_val, group=val_groups,\n", " categorical_feature=categorical_feature\n", " )\n", "\n", " # 训练模型\n", " model = lgb.train(\n", " params, train_dataset, num_boost_round=num_boost_round,\n", " valid_sets=[train_dataset, val_dataset], valid_names=['train', 'valid'],\n", " callbacks=callbacks\n", " )\n", "\n", " # 打印特征重要性（如果需要）\n", " if print_feature_importance:\n", " lgb.plot_metric(evals)\n", " lgb.plot_importance(model, importance_type='split', max_num_features=20)\n", " plt.show()\n", "\n", " return model, scaler, pca\n", "\n", "\n", "from catboost import CatBoostRanker, Pool\n", "import numpy as np\n", "\n", "\n", "def train_catboost(train_data_df, test_data_df, feature_columns, params=None, plot=False):\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", " scaler = StandardScaler()\n", " numeric_columns = X_train.select_dtypes(include=['float64', 'int64']).columns\n", " X_train.loc[:, numeric_columns] = scaler.fit_transform(X_train[numeric_columns])\n", " X_val.loc[:, numeric_columns] = scaler.transform(X_val[numeric_columns])\n", "\n", " group_train = train_data_df['trade_date'].factorize()[0]\n", " group_val = test_data_df['trade_date'].factorize()[0]\n", "\n", " cat_features = [i for i, col in enumerate(feature_columns) if col.startswith('cat')]\n", " print(f'cat_features: {cat_features}')\n", "\n", " train_pool = Pool(\n", " data=X_train,\n", " label=y_train,\n", " group_id=group_train,\n", " cat_features=cat_features\n", " )\n", "\n", " val_pool = Pool(\n", " data=X_val,\n", " label=y_val,\n", " group_id=group_val,\n", " cat_features=cat_features\n", " )\n", "\n", " # CatBoost 排序学习模型\n", " model = CatBoostRanker(**params)\n", " model.fit(train_pool, eval_set=val_pool, plot=plot, use_best_model=True)\n", "\n", " return model, scaler\n" ], "outputs": [], "execution_count": 56 }, { "cell_type": "code", "id": "c6eb5cd4-e714-420a-ac48-39af3e11ee81", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T15:03:18.426481Z", "start_time": "2025-04-03T15:02:19.926352Z" } }, "source": [ "print('train data size: ', len(train_data))\n", "\n", "label_gain = list(range(len(train_data['label'].unique())))\n", "label_gain = [gain * gain for gain in label_gain]\n", "light_params = {\n", " 'label_gain': label_gain,\n", " 'objective': 'lambdarank',\n", " 'metric': 'ndcg',\n", " 'learning_rate': 0.03,\n", " 'num_leaves': 32,\n", " # 'min_data_in_leaf': 128,\n", " 'max_depth': 8,\n", " 'max_bin': 32,\n", " 'feature_fraction': 0.7,\n", " 'bagging_fraction': 0.7,\n", " 'bagging_freq': 5,\n", " 'lambda_l1': 0.1,\n", " 'lambda_l2': 0.1,\n", " 'boosting': 'goss',\n", " 'verbosity': -1,\n", " 'extra_trees': True,\n", " 'max_position': 5,\n", " 'ndcg_at': 1,\n", " 'quant_train_renew_leaf': True,\n", " 'lambdarank_truncation_level': 1,\n", " 'lambdarank_position_bias_regularization': 1,\n", " 'seed': 7\n", "}\n", "evals = {}\n", "\n", "gc.collect()\n", "\n", "use_pca = False\n", "# feature_contri = [2 if feat.startswith('act_factor') or 'buy' in feat or 'sell' in feat else 1 for feat in feature_columns]\n", "# light_params['feature_contri'] = feature_contri\n", "# print(f'feature_contri: {feature_contri}')\n", "model, scaler, pca = train_light_model(train_data.dropna(subset=['label']),\n", " light_params, feature_columns,\n", " [lgb.log_evaluation(period=100),\n", " lgb.callback.record_evaluation(evals),\n", " lgb.early_stopping(100, first_metric_only=True)\n", " ], evals,\n", " num_boost_round=1000, validation_days=120,\n", " print_feature_importance=True, use_pca=use_pca)\n", "\n", "print('train data size: ', len(train_data))" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train data size: 590201\n", "原始训练集大小: 590201\n", "划分后的训练集大小: 537198, 验证集大小: 53003\n", "feature_columns size: 94\n", "Training until validation scores don't improve for 100 rounds\n", "[100]\ttrain's ndcg@1: 0.727839\tvalid's ndcg@1: 0.35097\n", "Early stopping, best iteration is:\n", "[67]\ttrain's ndcg@1: 0.702439\tvalid's ndcg@1: 0.403463\n", "Evaluated only: ndcg@1\n" ] }, { "data": { "text/plain": [ "
" ], "image/png": "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" }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "
" ], "image/png": "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" }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "train data size: 590201\n" ] } ], "execution_count": 62 }, { "cell_type": "code", "id": "5d1522a7538db91b", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T15:04:39.656944Z", "start_time": "2025-04-03T15:04:39.298483Z" } }, "source": [ "# train_data = train_data.sort_values(by='trade_date')\n", "# all_dates = train_data['trade_date'].unique() # 获取所有唯一的 trade_date\n", "# split_date = all_dates[-120] # 划分点为倒数第 validation_days 天\n", "# print(split_date)\n", "# print(all_dates)\n", "# val_data_split = train_data[train_data['trade_date'] >= split_date] # 验证集\n", "\n", "score_df = test_data\n", "numeric_columns = score_df.select_dtypes(include=['float64', 'int64']).columns\n", "numeric_columns = [col for col in numeric_columns if col in feature_columns]\n", "# score_df.loc[:, numeric_columns] = scaler.transform(score_df[numeric_columns])\n", "score_df = cross_sectional_standardization(score_df, numeric_columns)\n", "\n", "if use_pca and pca is not None:\n", " categorical_feature = [col for col in feature_columns if 'cat' in col]\n", " numeric_features = [col for col in feature_columns if col not in categorical_feature]\n", " numeric_pca = pca.transform(score_df[numeric_features])\n", " score_df = pd.concat([pd.DataFrame(numeric_pca), score_df[categorical_feature],\n", " score_df[['trade_date', 'ts_code', 'future_return', 'future_score', 'label']]], axis=1)\n", " score_df['score'] = model.predict(score_df[[col for col in score_df.columns if\n", " col not in ['trade_date', 'ts_code', 'future_return', 'future_score',\n", " 'label']]])\n", "else:\n", " score_df['score'] = model.predict(score_df[feature_columns])\n", "# train_data['score'] = catboost_model.predict(train_data[feature_columns])\n", "score_df = score_df.loc[score_df.groupby('trade_date')['score'].idxmax()]\n", "# score_df = score_df[score_df['score'] > 0]\n", "score_df[['trade_date', 'score', 'ts_code']].to_csv('predictions_test.tsv', index=False)\n", "print(score_df['label'].mean())\n", "print(score_df[['trade_date', 'ts_code', 'future_return', 'future_score', 'label']].head(10))" ], "outputs": [ { "ename": "NameError", "evalue": "name 'test_data' is not defined", "output_type": "error", "traceback": [ "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m", "\u001B[1;31mNameError\u001B[0m Traceback (most recent call last)", "Cell \u001B[1;32mIn[1], line 8\u001B[0m\n\u001B[0;32m 1\u001B[0m \u001B[38;5;66;03m# train_data = train_data.sort_values(by='trade_date')\u001B[39;00m\n\u001B[0;32m 2\u001B[0m \u001B[38;5;66;03m# all_dates = train_data['trade_date'].unique() # 获取所有唯一的 trade_date\u001B[39;00m\n\u001B[0;32m 3\u001B[0m \u001B[38;5;66;03m# split_date = all_dates[-120] # 划分点为倒数第 validation_days 天\u001B[39;00m\n\u001B[0;32m 4\u001B[0m \u001B[38;5;66;03m# print(split_date)\u001B[39;00m\n\u001B[0;32m 5\u001B[0m \u001B[38;5;66;03m# print(all_dates)\u001B[39;00m\n\u001B[0;32m 6\u001B[0m \u001B[38;5;66;03m# val_data_split = train_data[train_data['trade_date'] >= split_date] # 验证集\u001B[39;00m\n\u001B[1;32m----> 8\u001B[0m score_df \u001B[38;5;241m=\u001B[39m test_data\n\u001B[0;32m 9\u001B[0m numeric_columns \u001B[38;5;241m=\u001B[39m score_df\u001B[38;5;241m.\u001B[39mselect_dtypes(include\u001B[38;5;241m=\u001B[39m[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mfloat64\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mint64\u001B[39m\u001B[38;5;124m'\u001B[39m])\u001B[38;5;241m.\u001B[39mcolumns\n\u001B[0;32m 10\u001B[0m numeric_columns \u001B[38;5;241m=\u001B[39m [col \u001B[38;5;28;01mfor\u001B[39;00m col \u001B[38;5;129;01min\u001B[39;00m numeric_columns \u001B[38;5;28;01mif\u001B[39;00m col \u001B[38;5;129;01min\u001B[39;00m feature_columns]\n", "\u001B[1;31mNameError\u001B[0m: name 'test_data' is not defined" ] } ], "execution_count": 1 }, { "cell_type": "code", "id": "d86af99d15cb3bdd", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T15:03:25.791021Z", "start_time": "2025-04-03T15:03:25.537833Z" } }, "source": [ "print(df[(df['ts_code'] == '603577.SH') & (df['trade_date'] >= '2018-06-04')][\n", " ['trade_date', 'ts_code', 'close', 'open', 'future_return']])" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " trade_date ts_code close open future_return\n", "255411 2018-06-04 603577.SH 24.57 23.98 -0.044408\n", "257982 2018-06-05 603577.SH 23.45 24.32 -0.037819\n", "260550 2018-06-06 603577.SH 23.24 22.74 -0.052262\n", "263114 2018-06-07 603577.SH 21.88 22.77 -0.028451\n", "265676 2018-06-08 603577.SH 21.58 21.44 -0.002314\n", "... ... ... ... ... ...\n", "5105528 2025-03-24 603577.SH 20.82 20.67 -0.001921\n", "5108613 2025-03-25 603577.SH 20.33 20.82 -0.005411\n", "5111699 2025-03-26 603577.SH 20.78 20.33 -0.032771\n", "5114784 2025-03-27 603577.SH 20.22 20.75 NaN\n", "5117867 2025-03-28 603577.SH 20.07 20.20 NaN\n", "\n", "[1655 rows x 5 columns]\n" ] } ], "execution_count": 64 }, { "cell_type": "code", "id": "ef9d068e-67f7-412c-bbd8-cdee7492dbc9", "metadata": { "ExecuteTime": { "end_time": "2025-04-03T15:03:25.893508Z", "start_time": "2025-04-03T15:03:25.878525Z" } }, "source": [ "print(train_data[\"future_score\"].corr(train_data[\"label\"]))\n", "print(test_data[\"future_score\"].corr(test_data[\"label\"]))\n" ], "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.7684793250465913\n", "0.6965949564132026\n" ] } ], "execution_count": 65 } ], "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.11.11" } }, "nbformat": 4, "nbformat_minor": 5 }