#AI夏令营 #Datawhale夏令营

基于神经网络stack融合策略的多模型融合

改进点：

1.数据清洗，异常值替换（板块2）

2.基于神经网络的stack模型融合（板块6）

根据大佬的提示对Task3所做的改进，大佬链接：http://t.csdnimg.cn/RSC3o

1.模型导入

导入所需要包：

<code>import pandas as pd

import numpy as np

from sklearn.model_selection import StratifiedKFold, KFold, GroupKFold

import lightgbm as lgb

import xgboost as xgb

from catboost import CatBoostRegressor

from sklearn.metrics import mean_squared_error, mean_absolute_error

 2.数据信息展示及可视化

赛题数据由训练集和测试集组成，为了保证比赛的公平性，将每日日期进行脱敏，用1-N进行标识，即1为数据集最近一天，其中1-10为测试集数据。数据集由字段id（房屋id）、 dt（日标识）、type（房屋类型）、target（实际电力消耗）组成，如下图所示。

每个房间给出其从第11-506天的电力消耗,共2877305行，5832个房间，19种房间类型，下图为train.csv的数据展示。

 房间类型与电力消耗关系如下图所示：

<code>import matplotlib.pyplot as plt

import pandas as pd

import matplotlib.cm as cm

plt.rcParams['font.family'] = ['SimHei']

plt.rcParams['axes.unicode_minus'] = False

target = train.groupby('type')['target'].mean().reset_index()

plt.figure(figsize=(6, 4))

norm = plt.Normalize(vmin=0, vmax=len(target['type'].unique())-1)

colors = cm.viridis(norm(range(len(target['type'].unique()))))

plt.bar(target['type'], target['target'], color=colors)

plt.xlabel('房间类型')

plt.ylabel('平均消耗电力')

plt.title('房间类型与电力消耗关系')

plt.show()

 以第一个房间编号为例，展示其随时间的电力变化，如下图所示：

<code>id_all = train[train['id'] == '00037f39cf']

plt.figure(figsize=(8, 4))

plt.plot(id_all['dt'], id_all['target'], linestyle='-')code>

plt.xlabel('日期')

plt.ylabel('电力消耗')

plt.title('电力消耗随日期变化')

plt.show()

通过该图可知，数据有明显的异常值，需要进行数据筛除以及补全，故对全篇数据进行循环，检查数据合理性，对不合理数据进行平均值替换，得出新的train.csv文件

<code>#数据预处理，异常值转换

products = train['id'].unique()

# 创建一个空的 DataFrame 来存储修改后的数据

modified_train = train.copy()

for product in products:

# 筛选出特定产品的数据

id_all = modified_train[modified_train['id'] == product]

ls = id_all['target'].tolist() # 转换为列表以便修改

# 使用列表推导式来处理异常值

new_ls = [ls[0]] # 初始值，避免索引-1错误

for i in range(1, len(ls) - 1):

if abs(ls[i] - ls[i - 1]) >= 10 and abs(ls[i] - ls[i + 1]) >= 10:

ll=(ls[i - 1] + ls[i + 1]) / 2

new_ls.append(ll)

else:

new_ls.append(ls[i])

new_ls.append(ls[-1]) # 添加最后一个值，避免索引超出范围

# 更新 DataFrame 中的 target 列

modified_train.loc[modified_train['id'] == product, 'target'] = new_ls

# 最后，将所有修改后的数据写入 CSV 文件

modified_train[['id', 'dt', 'type', 'target']].to_csv('train1.csv', index=None)

结果如图所示，图像相比变得较为平滑，突出数据减少，但是这里判断合理性只考虑数据和其相邻数据，数据清洗不是很全面，可以具体详细更改。

 3.特征提取

这里主要构建了历史平移特征、差分特征、和窗口统计特征；具体说明如下：

（1）历史平移特征：通过历史平移获取上个阶段的信息；

（2）差分特征：可以帮助获取相邻阶段的增长差异，描述数据的涨减变化情况。在此基础上还可以构建相邻数据比值变化、二阶差分等；

（3）窗口统计特征：窗口统计可以构建不同的窗口大小，然后基于窗口范围进统计均值、最大值、最小值、中位数、方差的信息，可以反映最近阶段数据的变化情况。

<code># 合并训练数据和测试数据

data = pd.concat([train, test], axis=0).reset_index(drop=True)

data = data.sort_values(['id','dt'], ascending=False).reset_index(drop=True)

# 历史平移

for i in range(10,36):

data[f'target_shift{i}'] = data.groupby('id')['target'].shift(i)

# 历史平移 + 差分特征

for i in range(1,4):

data[f'target_shift10_diff{i}'] = data.groupby('id')['target_shift10'].diff(i)

# 窗口统计

for win in [15,30,50,70]:

data[f'target_win{win}_mean'] = data.groupby('id')['target'].rolling(window=win, min_periods=3, closed='left').mean().valuescode>

data[f'target_win{win}_max'] = data.groupby('id')['target'].rolling(window=win, min_periods=3, closed='left').max().valuescode>

data[f'target_win{win}_min'] = data.groupby('id')['target'].rolling(window=win, min_periods=3, closed='left').min().valuescode>

data[f'target_win{win}_std'] = data.groupby('id')['target'].rolling(window=win, min_periods=3, closed='left').std().valuescode>

# 历史平移 + 窗口统计

for win in [7,14,28,35,50,70]:

data[f'target_shift10_win{win}_mean'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').mean().valuescode>

data[f'target_shift10_win{win}_max'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').max().valuescode>

data[f'target_shift10_win{win}_min'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').min().valuescode>

data[f'target_shift10_win{win}_sum'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').sum().valuescode>

data[f'target_shift710win{win}_std'] = data.groupby('id')['target_shift10'].rolling(window=win, min_periods=3, closed='left').std().valuescode>

train = data[data.target.notnull()].reset_index(drop=True)

test = data[data.target.isnull()].reset_index(drop=True)

train_cols = [f for f in data.columns if f not in ['id','target']]

4.三种机器学习模型对数据的预测 

以下代码定义了一个名为<code>stack_model_nn的函数，它实现了一个使用神经网络作为元学习器的堆叠模型（Stacking Model）过程。函数接收来自三个基础模型（如LightGBM、XGBoost和CatBoost）的OOF（Out-Of-Fold）预测和测试集预测结果，以及训练集的真实标签。首先，它将输入的数据从Series转换为DataFrame，并将OOF预测和测试预测结果分别拼接成新的DataFrame。

接下来，函数通过多次重复K折交叉验证（RepeatedKFold）来训练一个神经网络模型。在每个折叠中，它使用当前折叠的训练数据（即基础模型的OOF预测结果）来训练神经网络，并在验证集上进行预测以评估模型性能。神经网络模型包含三个密集层（Dense layers），使用ReLU激活函数和Adam优化器，以平均绝对误差（MAE）作为损失函数。

在每次验证后，函数计算并记录模型在验证集上的MAE分数，并将神经网络在测试集上的预测结果进行累加平均，以便最终得到整个测试集的预测。最后，函数返回堆叠模型在训练集上的OOF预测和测试集上的预测结果，以及验证过程中所有折叠的平均分数。

通过这种方式，stack_model_nn函数利用神经网络作为元学习器来整合不同基础模型的预测，旨在提高模型的预测准确性和泛化能力。

def stack_model_nn(oof_1, oof_2, oof_3, predictions_1, predictions_2, predictions_3, y):

# 将Series转换为DataFrame

oof_1, oof_2, oof_3 = pd.DataFrame(oof_1), pd.DataFrame(oof_2), pd.DataFrame(oof_3)

predictions_1, predictions_2, predictions_3 = pd.DataFrame(predictions_1), pd.DataFrame(predictions_2), pd.DataFrame(predictions_3)

# 拼接OOF和测试预测

train_stack = pd.concat([oof_1, oof_2, oof_3], axis=1)

test_stack = pd.concat([predictions_1, predictions_2, predictions_3], axis=1)

oof = np.zeros(train_stack.shape[0])

predictions = np.zeros(test_stack.shape[0])

scores = []

folds = RepeatedKFold(n_splits=5, n_repeats=2, random_state=2021)

for fold_, (trn_idx, val_idx) in enumerate(folds.split(train_stack, y)):

print(f"fold n°{fold_+1}")

trn_data, trn_y = train_stack.iloc[trn_idx], y.iloc[trn_idx]

val_data, val_y = train_stack.iloc[val_idx], y.iloc[val_idx]

# 定义神经网络模型

model = Sequential([

Dense(128, activation='relu', input_shape=(trn_data.shape[1],)), code>

Dense(64, activation='relu'), code>

Dense(1)

])

model.compile(optimizer=Adam(), loss='mean_absolute_error') code>

# 预测

oof[val_idx] = model.predict(val_data).flatten()

predictions += model.predict(test_stack).flatten() / len(folds.split(train_stack, y))

# 计算并打印分数

score_single = mean_absolute_error(val_y, oof[val_idx])

scores.append(score_single)

print(f'{fold_+1}/{5}', score_single)

print('mean: ', np.mean(scores))

return oof, predictions

stack_oof, stack_pred1 = stack_model_nn(lgb_oof, xgb_oof, cat_oof, lgb_test, xgb_test, cat_test, train['target'])

本代码仅起抛砖引玉的作用，最后的结果就不贴了，欢迎各位大佬进行进一步的改进。