#AI夏令营 #Datawhale #夏令营

1.赛事简介

随着全球经济的快速发展和城市化进程的加速，电力系统面临着越来越大的挑战。电力需求的准确预测对于电网的稳定运行、能源的有效管理以及可再生能源的整合至关重要。

2.赛事任务

给定多个房屋对应电力消耗历史N天的相关序列数据等信息，预测房屋对应电力的消耗。

2024 iFLYTEK A.I.开发者大赛-讯飞开放平台  

3.Task2：进阶lightgbm，开始特征工程

（1）导入模块：此部分包含代码所需的模块

<code>import numpy as np

import pandas as pd

import lightgbm as lgb

from sklearn.metrics import mean_squared_log_error, mean_absolute_error

import tqdm

import sys

import os

import gc

import argparse

import warnings

warnings.filterwarnings('ignore')

（2）数据准备

在数据准备阶段，主要读取训练数据和测试数据，并进行基本的数据展示。

train = pd.read_csv('./data/train.csv')

test = pd.read_csv('./data/test.csv')

数据简单介绍：其中id为房屋id，dt为日标识，训练数据dt最小为11，不同id对应序列长度不同；type为房屋类型，通常而言不同类型的房屋整体消耗存在比较大的差异；target为实际电力消耗，也是我们的本次比赛的预测目标。下面进行简单的可视化分析，帮助我们对数据有个简单的了解。

不同type类型对应target的柱状图

<code>import matplotlib.pyplot as plt

# 不同type类型对应target的柱状图

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

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

plt.bar(type_target_df['type'], type_target_df['target'], color=['blue', 'green'])

plt.xlabel('Type')

plt.ylabel('Average Target Value')

plt.title('Bar Chart of Target by Type')

plt.show()

id为00037f39cf的按dt为序列关于target的折线图

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

plt.figure(figsize=(10, 5))

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

plt.xlabel('DateTime')

plt.ylabel('Target Value')

plt.title("Line Chart of Target for ID '00037f39cf'")

plt.show()

（3）特征工程

这里主要构建了历史平移特征和窗口统计特征；每种特征都是有理可据的，具体说明如下：

历史平移特征：通过历史平移获取上个阶段的信息；如下图所示，可以将d-1时间的信息给到d时间，d时间信息给到d+1时间，这样就实现了平移一个单位的特征构建。

窗口统计特征：窗口统计可以构建不同的窗口大小，然后基于窗口范围进统计均值、最大值、最小值、中位数、方差的信息，可以反映最近阶段数据的变化情况。如下图所示，可以将d时刻之前的三个时间单位的信息进行统计构建特征给我d时刻。

<code># 合并训练数据和测试数据，并进行排序

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

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

# 历史平移

for i in range(10,30):

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

# 窗口统计

data[f'win3_mean_target'] = (data['last10_target'] + data['last11_target'] + data['last12_target']) / 3

# 进行数据切分

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）模型训练与测试集预测

选择使用Lightgbm模型，也是通常作为数据挖掘比赛的基线模型，在不需要过程调参的情况的也能得到比较稳定的分数。另外需要注意的是，训练集和验证集的构建，因为数据存在时序关系，所以严格按照时序进行切分，这里选择原始给出训练数据集dt为30之后作为训练数据，之前的数据作为验证数据，这样保证了数据不存在穿越问题（不使用未来数据预测历史数据）。

def time_model(clf, train_df, test_df, cols):

# 训练集和验证集切分

trn_x, trn_y = train_df[train_df.dt>=31][cols], train_df[train_df.dt>=31]['target']

val_x, val_y = train_df[train_df.dt<=30][cols], train_df[train_df.dt<=30]['target']

# 构建模型输入数据

train_matrix = clf.Dataset(trn_x, label=trn_y)

valid_matrix = clf.Dataset(val_x, label=val_y)

# lightgbm参数

lgb_params = {

'boosting_type': 'gbdt',

'objective': 'regression',

'metric': 'mse',

'min_child_weight': 5,

'num_leaves': 2 ** 5,

'lambda_l2': 10,

'feature_fraction': 0.8,

'bagging_fraction': 0.8,

'bagging_freq': 4,

'learning_rate': 0.05,

'seed': 2024,

'nthread' : 16,

'verbose' : -1,

}

# 训练模型

model = clf.train(lgb_params, train_matrix, 50000, valid_sets=[train_matrix, valid_matrix],

categorical_feature=[], verbose_eval=500, early_stopping_rounds=500)

# 验证集和测试集结果预测

val_pred = model.predict(val_x, num_iteration=model.best_iteration)

test_pred = model.predict(test_df[cols], num_iteration=model.best_iteration)

# 离线分数评估

score = mean_squared_error(val_pred, val_y)

print(score)

return val_pred, test_pred

lgb_oof, lgb_test = time_model(lgb, train, test, train_cols)

# 保存结果文件到本地

test['target'] = lgb_test

test[['id','dt','target']].to_csv('submit.csv', index=None)

得到

分数。

4.进阶——特征优化

这里主要构建了历史平移特征、差分特征、和窗口统计特征；每种特征都是有理可据的，具体说明如下：

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

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

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

参考代码如下：

<code># 历史平移

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>

分值有很大的提升，特征工程的重要性不言而喻。

5.尝试不同的算法

后来尝试了catboost、xgboost等算法，但是效果都不是很好。

6.模型融合

<code>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

def cv_model(clf, train_x, train_y, test_x, clf_name, seed = 2024):

'''

clf：调用模型

train_x：训练数据

train_y：训练数据对应标签

test_x：测试数据

clf_name：选择使用模型名

seed：随机种子

'''

folds = 5

kf = KFold(n_splits=folds, shuffle=True, random_state=seed)

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

test_predict = np.zeros(test_x.shape[0])

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': 'regression',

'metric': 'mae',

'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.1,

'seed': 2023,

'nthread' : 16,

'verbose' : -1,

}

model = clf.train(params, train_matrix, 1000, valid_sets=[train_matrix, valid_matrix],

categorical_feature=[], verbose_eval=200, 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': 'reg:squarederror',

'eval_metric': 'mae',

'max_depth': 5,

'lambda': 10,

'subsample': 0.7,

'colsample_bytree': 0.7,

'colsample_bylevel': 0.7,

'eta': 0.1,

'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=1000, evals=watchlist, verbose_eval=200, early_stopping_rounds=100)

val_pred = model.predict(valid_matrix)

test_pred = model.predict(test_matrix)

if clf_name == "cat":

params = {'learning_rate': 0.1, 'depth': 5, 'bootstrap_type':'Bernoulli','random_seed':2023,

'od_type': 'Iter', 'od_wait': 100, 'random_seed': 11, 'allow_writing_files': False}

model = clf(iterations=1000, **params)

model.fit(trn_x, trn_y, eval_set=(val_x, val_y),

metric_period=200,

use_best_model=True,

cat_features=[],

verbose=1)

val_pred = model.predict(val_x)

test_pred = model.predict(test_x)

oof[valid_index] = val_pred

test_predict += test_pred / kf.n_splits

score = mean_absolute_error(val_y, val_pred)

cv_scores.append(score)

print(cv_scores)

return oof, test_predict

# 选择lightgbm模型

lgb_oof, lgb_test = cv_model(lgb, train[train_cols], train['target'], test[train_cols], 'lgb')

# 选择xgboost模型

xgb_oof, xgb_test = cv_model(xgb, train[train_cols], train['target'], test[train_cols], 'xgb')

# 选择catboost模型

cat_oof, cat_test = cv_model(CatBoostRegressor, train[train_cols], train['target'], test[train_cols], 'cat')

# 进行取平均融合

final_test = (lgb_test + xgb_test + cat_test) / 3

参考给的代码做了模型融合，效果不佳，还是得继续优化特征！