一、赛题理解

1. 赛题名称

AI量化模型预测

2. 赛题理解

本赛事是一个量化金融挑战，旨在通过大数据与机器学习的方法，使用给定的训练集和测试集数据，预测未来中间价的移动方向。参赛者需要理解市场行为的原理，创建量化策略，并利用过去不超过100个数据点的信息，对未来5、10、20、40和60个数据点的中间价进行预测（下跌、不变或上涨）。挑战包含10只股票，79个交易日的数据，其中前64个交易日用于训练，后15个用于测试。数据集包括股票的5档量价、中间价、交易量等信息。

3. 赛题链接2023 iFLYTEK A.I.开发者大赛-讯飞开放平台 (xfyun.cn)https://challenge.xfyun.cn/topic/info?type=quantitative-model4. 评估指标

macro-F1 score，具体公式如下：

$Precision_i = \frac{TP_i}{TP_i + FP_i} Recall_i = \frac{TP_i}{TP_i + FN_i}$

$F1_i = \frac{2 \cdot Precision_i \cdot Recall_i}{Precision_i + Recall_i}$

$Macro-F1 score = \frac{1}{n} \sum_{i=1}^{n} F1_i$

二、数据竞赛开发步骤

1. 问题分析

问题分析是竞赛的第一步，它涉及对问题进行定义、目标明确化和数据需求的识别。

2. 数据清洗
在采集数据完后，对数据进行数据清洗，即把采集到的、不适合用来做机器学习训练的数据进行预处理，从而转化为适合机器学习的数据。

3. 数据探索

对清洗后的数据进行可视化和统计分析的过程。通过数据探索，可以深入了解数据的特征、分布、相关性等情况，发现数据之间的模式和趋势，为特征工程和特征筛选提供指导。常见的数据探索方法包括绘制直方图、散点图、箱线图等图形，计算统计指标如均值、方差、相关系数等。

4. 特征工程

根据数据的领域知识和探索结果，对原始数据进行变换、组合、衍生等操作，以创建更有意义、更能表达问题特征的新特征。好的特征工程可以提高模型的性能和泛化能力。常见的特征工程包括特征缩放、编码分类变量、处理时间序列数据、创建多项式特征等。

5. 特征筛选

通过一定的评估方法选择对模型训练最有用的特征，去除冗余或不相关的特征。这样可以降低模型复杂度，加快训练速度，减少过拟合的可能性，并提高模型的解释性。常见的特征筛选方法包括基于统计的方法、基于模型的方法和基于特征重要性的方法。

6. 模型训练

使用清洗、探索和筛选后的数据来训练机器学习模型的过程。根据问题的类型和数据的特点，可以选择合适的机器学习算法和模型架构进行训练。训练过程涉及优化模型参数，使其能够最好地拟合训练数据，并能在未见过的数据上泛化。

7. 模型保存

模型训练完成后，需要将训练得到的模型保存起来，以便在后续部署和使用中使用。模型保存可以包括保存模型权重、参数和架构，以及相关的辅助信息。在实际应用中，保存的模型可以用于预测新数据的结果或作为其他任务的基础。

当然，对于上面的特征工程不是一步到位的，而是不断的通过模型训练的结果进行不断的优化调整，直到最优的特征组合。

三、 baseline详细解读

1. 数据读取

首先使用os模块中的listdir读取训练集的文件列表保存到train_files中，创建一个空的训练数据DataFrame，然后遍历每个训练集文件使用pd.read_csv进行csv文件读取并存入临时的DataFrame：tmp中，同时将当前文件名作为列添加到临时tmp，最后将当前临时DataFrame与主训练数据DataFrame进行合并。测试集与上面训练集一样。

# 定义文件路径
path = 'AI量化模型预测挑战赛公开数据/'
# 读取训练集文件列表
train_files = os.listdir(path+'train')
# 创建一个空的训练数据DataFrame
train_df = pd.DataFrame()
# 遍历每个训练集文件
for filename in tqdm.tqdm(train_files):# 读取CSV文件并存入临时DataFrametmp = pd.read_csv(path+'train/'+filename)# 将当前文件名作为列添加到临时DataFrametmp['file'] = filename# 将当前临时DataFrame与主训练数据DataFrame进行合并train_df = pd.concat([train_df, tmp], axis=0, ignore_index=True)# 读取测试集文件列表
test_files = os.listdir(path+'test')
# 创建一个空的测试数据DataFrame
test_df = pd.DataFrame()
# 遍历每个测试集文件
for filename in tqdm.tqdm(test_files):# 读取CSV文件并存入临时DataFrametmp = pd.read_csv(path+'test/'+filename)# 将当前文件名作为列添加到临时DataFrametmp['file'] = filename# 将当前临时DataFrame与主测试数据DataFrame进行合并test_df = pd.concat([test_df, tmp], axis=0, ignore_index=True)

在通过遍历文件目录，再使用pd.read_csv读取文件，文件比较多，因此读取慢。如果把读取后的数据直接保存到本地，再直接加载，那么就会提高读取的速度。python中有一个内置库pickle，可以保存程序中的变量到本地，然后通过pickle加载本地数据就可以实现读取速度优化。

# 训练集和测试集文件保存
# Save 'train_df' to a file using pickle
with open('train_df.pickle', 'wb') as f:pickle.dump(train_df, f)# Save 'test_df' to a file using pickle
with open('test_df.pickle', 'wb') as f:pickle.dump(test_df, f)# 训练集和测试集文件读取
# Load 'train_df' from the saved file
with open('train_df.pickle', 'rb') as f:train_df = pickle.load(f)# Load 'test_df' from the saved file
with open('test_df.pickle', 'rb') as f:test_df = pickle.load(f)

2. 特征构造

（1）提取时间信息，同时为了保证时间的一致性，故进行排序

# 时间相关特征
train_df['hour'] = train_df['time'].apply(lambda x:int(x.split(':')[0]))
test_df['hour'] = test_df['time'].apply(lambda x:int(x.split(':')[0]))train_df['minute'] = train_df['time'].apply(lambda x:int(x.split(':')[1]))
test_df['minute'] = test_df['time'].apply(lambda x:int(x.split(':')[1]))# 为了保证时间顺序的一致性，故进行排序
train_df = train_df.sort_values(['file','time'])
test_df = test_df.sort_values(['file','time'])

（2）计算每个样本的加权平均价格（Weighted Average Price，WAP）作为新的特征，并将其命名为'wap1', 'wap2', 'wap3', 'wap4'。通过对买入价和卖出价以及对应的数量进行加权平均，旨在更好地反映市场交易价格的趋势和情况。

# 对训练集进行特征工程
# 计算买一价和卖一价的加权平均作为新特征'wap1'，加权平均的计算方式是：(买一价 * 买一量 + 卖一价 * 卖一量) / (买一量 + 卖一量)
train_df['wap1'] = (train_df['n_bid1'] * train_df['n_bsize1'] + train_df['n_ask1'] * train_df['n_asize1']) / (train_df['n_bsize1'] + train_df['n_asize1'])
# 计算买二价和卖二价的加权平均作为新特征'wap2'，加权平均的计算方式同样是：(买二价 * 买二量 + 卖二价 * 卖二量) / (买二量 + 卖二量)
train_df['wap2'] = (train_df['n_bid2'] * train_df['n_bsize2'] + train_df['n_ask2'] * train_df['n_asize2']) / (train_df['n_bsize2'] + train_df['n_asize2'])
# 计算买三价和卖三价的加权平均作为新特征'wap3'，加权平均的计算方式同样是：(买三价 * 买三量 + 卖三价 * 卖三量) / (买三量 + 卖三量)
train_df['wap3'] = (train_df['n_bid3'] * train_df['n_bsize3'] + train_df['n_ask3'] * train_df['n_asize3']) / (train_df['n_bsize3'] + train_df['n_asize3'])
# 计算买四价和卖四价的加权平均作为新特征'wap4'，加权平均的计算方式同样是：(买四价 * 买四量 + 卖四价 * 卖四量) / (买四量 + 卖四量)
train_df['wap4'] = (train_df['n_bid4'] * train_df['n_bsize4'] + train_df['n_ask4'] * train_df['n_asize4']) / (train_df['n_bsize4'] + train_df['n_asize4'])# 对测试集进行特征工程，步骤同训练集一样
test_df['wap1'] = (test_df['n_bid1'] * test_df['n_bsize1'] + test_df['n_ask1'] * test_df['n_asize1']) / (test_df['n_bsize1'] + test_df['n_asize1'])
test_df['wap2'] = (test_df['n_bid2'] * test_df['n_bsize2'] + test_df['n_ask2'] * test_df['n_asize2']) / (test_df['n_bsize2'] + test_df['n_asize2'])
test_df['wap3'] = (test_df['n_bid3'] * test_df['n_bsize3'] + test_df['n_ask3'] * test_df['n_asize3']) / (test_df['n_bsize3'] + test_df['n_asize3'])
test_df['wap4'] = (test_df['n_bid4'] * test_df['n_bsize4'] + test_df['n_ask4'] * test_df['n_asize4']) / (test_df['n_bsize4'] + test_df['n_asize4'])

（3）围绕买卖价格和买卖量进行计算

'wap_balance': 该特征计算了'wap1'和'wap2'之间的差值的绝对值。反映出买卖价格之间的平衡情况，即市场在买卖价格上的趋势或震荡程度。

'bid_spread': 该特征计算了买一价和买二价之间的差值。展示买价的变化情况，可能与市场的需求和供应有关。

'ask_spread': 该特征计算了卖一价和卖二价之间的差值。类似于'bid_spread'，展示卖价的变化情况。

'total_volume': 该特征计算了买一量、买二量、卖一量和卖二量之和。表示市场的总交易量，可能与市场的活跃度和流动性有关。

'volume_imbalance': 该特征计算了买一量、买二量、卖一量和卖二量之间的差值的绝对值。表示买入和卖出量之间的差异，可能反映了市场上买卖双方的力量对比。

# 对训练集进行当前时间特征的构建
# 计算'wap1'和'wap2'之间的差值的绝对值作为新特征'wap_balance'
train_df['wap_balance'] = abs(train_df['wap1'] - train_df['wap2'])
# 计算买一价和买二价之间的差值作为新特征'bid_spread'
train_df['bid_spread'] = train_df['n_bid1'] - train_df['n_bid2']
# 计算卖一价和卖二价之间的差值作为新特征'ask_spread'
train_df['ask_spread'] = train_df['n_ask1'] - train_df['n_ask2']
# 计算买一量、买二量、卖一量和卖二量之和作为新特征'total_volume'
train_df['total_volume'] = (train_df['n_asize1'] + train_df['n_asize2']) + (train_df['n_bsize1'] + train_df['n_bsize2'])
# 计算买一量、买二量、卖一量和卖二量之间的差值的绝对值作为新特征'volume_imbalance'
train_df['volume_imbalance'] = abs((train_df['n_asize1'] + train_df['n_asize2']) - (train_df['n_bsize1'] + train_df['n_bsize2']))# 对测试集进行当前时间特征的构建，步骤同训练集一样
test_df['wap_balance'] = abs(test_df['wap1'] - test_df['wap2'])
test_df['bid_spread'] = test_df['n_bid1'] - test_df['n_bid2']
test_df['ask_spread'] = test_df['n_ask1'] - test_df['n_ask2']
test_df['total_volume'] = (test_df['n_asize1'] + test_df['n_asize2']) + (test_df['n_bsize1'] + test_df['n_bsize2'])
test_df['volume_imbalance'] = abs((test_df['n_asize1'] + test_df['n_asize2']) - (test_df['n_bsize1'] + test_df['n_bsize2']))

（4）历史平移

在训练集和测试集中，对特定的列进行历史平移，通过shift函数，将当前样本的特征值移动到之前的时间点。对于每个要平移的特征（如'wap1','wap2','wap_balance'等），使用不同的时间偏移量（1、5、10、20、40、60）来创建新特征。例如，'file_wap1_shift1'表示'wap1'特征向前平移一个时间点。

# 历史平移
# 对每个特征进行不同时间偏移量的历史平移，生成新特征
for val in ['wap1','wap2','wap_balance','price_spread','bid_spread','ask_spread','total_volume','volume_imbalance']:for loc in [1,5,10,20,40,60]:# 对训练集进行历史平移，按照文件分组后对特征进行时间偏移，shift(loc)表示向前平移loc个时间点train_df[f'file_{val}_shift{loc}'] = train_df.groupby(['file'])[val].shift(loc)# 对测试集进行历史平移，步骤同训练集一样test_df[f'file_{val}_shift{loc}'] = test_df.groupby(['file'])[val].shift(loc)

（5）差分特征

类似于历史平移，对每个要处理的特征进行差分计算。通过diff函数，计算当前样本与之前时间点的差异，用于观察特征值之间的增长关系。对于每个要处理的特征和不同的时间差（1、5、10、20、40、60），生成新特征。例如，'file_wap1_diff1'表示'wap1'特征与前一个时间点的差异。

# 差分特征
# 对每个特征进行不同时间差的差分计算，生成新特征
for val in ['wap1','wap2','wap_balance','price_spread','bid_spread','ask_spread','total_volume','volume_imbalance']:for loc in [1,5,10,20,40,60]:# 对训练集进行差分计算，按照文件分组后对特征进行时间差计算，diff(loc)表示与前loc个时间点的差异train_df[f'file_{val}_diff{loc}'] = train_df.groupby(['file'])[val].diff(loc)# 对测试集进行差分计算，步骤同训练集一样test_df[f'file_{val}_diff{loc}'] = test_df.groupby(['file'])[val].diff(loc)

（6）窗口统计

使用滑动窗口来计算历史信息的统计数据，如均值和标准差。对于每个要处理的特征，分别计算滑动窗口大小为7的均值和标准差。这样可以获取历史信息在窗口内的分布变化信息。例如，'file_wap1_win7_mean'表示'wap1'特征在滑动窗口大小为7的窗口内的均值。

# 窗口统计
# 对每个特征进行滑动窗口统计，生成均值和标准差特征
for val in ['wap1','wap2','wap_balance','price_spread','bid_spread','ask_spread','total_volume','volume_imbalance']:# 计算滑动窗口大小为7的均值特征，min_periods=3表示窗口内至少包含3个有效值train_df[f'file_{val}_win7_mean'] = train_df.groupby(['file'])[val].transform(lambda x: x.rolling(window=7, min_periods=3).mean())# 计算滑动窗口大小为7的标准差特征train_df[f'file_{val}_win7_std'] = train_df.groupby(['file'])[val].transform(lambda x: x.rolling(window=7, min_periods=3).std())# 对测试集进行窗口统计，步骤同训练集一样test_df[f'file_{val}_win7_mean'] = test_df.groupby(['file'])[val].transform(lambda x: x.rolling(window=7, min_periods=3).mean())test_df[f'file_{val}_win7_std'] = test_df.groupby(['file'])[val].transform(lambda x: x.rolling(window=7, min_periods=3).std())

3. 模型训练

（1）cv_model函数

参数：clf是机器学习模型的类对象，train_x是训练集特征，train_y是训练集标签，test_x是测试集特征，clf_name是模型的名称，seed是随机种子。
返回：函数返回训练集的交叉验证预测结果oof和测试集的预测结果test_predict。
交叉验证：

（2）交叉验证

使用5折交叉验证（folds = 5），将训练数据集分成5个子集，依次用其中4个子集作为训练集，另一个子集作为验证集，进行5轮训练和验证，以得到更稳定的模型评估结果。

（3）模型训练和预测：

对于每一折，根据指定的模型名称（clf_name），选择相应的分类器（LightGBM、XGBoost或CatBoost）。设置分类器的超参数，例如学习率、树的深度、正则化参数等。使用训练数据集（trn_x和trn_y）进行模型训练，并使用验证数据集（val_x）进行验证。使用训练好的模型对验证数据集和测试数据集（test_x）进行预测。

（4）模型融合：

每一折，将验证集的预测结果（val_pred）存储在oof中，用于后续模型融合。
每一折，将测试集的预测结果（test_pred）进行累加，最后除以折数（kf.n_splits）得到测试集的平均预测结果。

（5）F1得分和评估：

每一折，计算验证集预测结果的F1得分，并将其存储在cv_scores列表中。

（6）模型融合和输出：

将三个模型（LightGBM、XGBoost和CatBoost）的测试集预测结果取平均，得到最终的测试集预测结果final_test，用于提交和生成最终的预测结果。

def cv_model(clf, train_x, train_y, test_x, clf_name, seed = 2023):folds = 5kf = KFold(n_splits=folds, shuffle=True, random_state=seed)oof = np.zeros([train_x.shape[0], 3])test_predict = np.zeros([test_x.shape[0], 3])cv_scores = []for i, (train_index, valid_index) in enumerate(kf.split(train_x, train_y)):print('************************************ {} ************************************'.format(str(i+1)))trn_x, trn_y, val_x, val_y = train_x.iloc[train_index], train_y[train_index], train_x.iloc[valid_index], train_y[valid_index]if clf_name == "lgb":train_matrix = clf.Dataset(trn_x, label=trn_y)valid_matrix = clf.Dataset(val_x, label=val_y)params = {'boosting_type': 'gbdt','objective': 'multiclass','num_class':3,'min_child_weight': 6,'num_leaves': 2 ** 6,'lambda_l2': 10,'feature_fraction': 0.8,'bagging_fraction': 0.8,'bagging_freq': 4,'learning_rate': 0.35,'seed': 2023,'nthread' : 16,'verbose' : -1,}model = clf.train(params, train_matrix, 2000, valid_sets=[train_matrix, valid_matrix],categorical_feature=[], verbose_eval=1000, early_stopping_rounds=100)val_pred = model.predict(val_x, num_iteration=model.best_iteration)test_pred = model.predict(test_x, num_iteration=model.best_iteration)if clf_name == "xgb":xgb_params = {'booster': 'gbtree', 'objective': 'multi:softprob','num_class':3,'max_depth': 5,'lambda': 10,'subsample': 0.7,'colsample_bytree': 0.7,'colsample_bylevel': 0.7,'eta': 0.35,'tree_method': 'hist','seed': 520,'nthread': 16}train_matrix = clf.DMatrix(trn_x , label=trn_y)valid_matrix = clf.DMatrix(val_x , label=val_y)test_matrix = clf.DMatrix(test_x)watchlist = [(train_matrix, 'train'),(valid_matrix, 'eval')]model = clf.train(xgb_params, train_matrix, num_boost_round=2000, evals=watchlist, verbose_eval=1000, early_stopping_rounds=100)val_pred  = model.predict(valid_matrix)test_pred = model.predict(test_matrix)if clf_name == "cat":params = {'learning_rate': 0.35, 'depth': 5, 'bootstrap_type':'Bernoulli','random_seed':2023,'od_type': 'Iter', 'od_wait': 100, 'random_seed': 11, 'allow_writing_files': False,'loss_function': 'MultiClass'}model = clf(iterations=2000, **params)model.fit(trn_x, trn_y, eval_set=(val_x, val_y),metric_period=1000,use_best_model=True, cat_features=[],verbose=1)val_pred  = model.predict_proba(val_x)test_pred = model.predict_proba(test_x)oof[valid_index] = val_predtest_predict += test_pred / kf.n_splitsF1_score = f1_score(val_y, np.argmax(val_pred, axis=1), average='macro')cv_scores.append(F1_score)print(cv_scores)return oof, test_predict# 选择lightgbm模型
lgb_oof, lgb_test = cv_model(lgb, train_df[cols], train_df['label_5'], test_df[cols], 'lgb')
# 选择xgboost模型
xgb_oof, xgb_test = cv_model(xgb, train_df[cols], train_df['label_5'], test_df[cols], 'xgb')
# 选择catboost模型
cat_oof, cat_test = cv_model(CatBoostClassifier, train_df[cols], train_df['label_5'], test_df[cols], 'cat')# 进行取平均融合
final_test = (lgb_test + xgb_test + cat_test) / 3

注意：在使用进阶方案之后，会发现进阶方案比开始的方案要低的原因：

在进阶方案中新添加了许多的特征工程，而使得特征数量增多，而原来的模型训练中迭代次数很少，这就会导致模型还没有学习到特征而提前终止了模型训练，此时就需要我们自己手动调整迭代次数，可以增大到5000或者更大，有早停处理，不用担心会一直训练下去。当然学习率调得很低的话会导致模型迭代次数增大，如果觉得模型不断的迭代太多了的话可以调大学习率。