一：概述
这个赛道的训练营主要就是结合第三届世界科学智能大赛新能源赛道：新能源发电功率预测这个比赛来实施的。下来会带领针对这个训练营的一系列详细操作，实现这个需求功能。
二：具体说明
<1>任务和主题
AI新能源功率预报：根据历史发电率数据和对应的时段多类别气象预测数据，实现次日零时起未来14小时逐15分钟级新能源场站发电功率预测。
<2>具体步骤-正式分析赛题前
默认在此之前，已经有了魔塔社区的账号，接下来，通过以下的步骤，开启一个实例。
如果你是第一次使用这个的话，会让你实名认证绑定，认证完成后才可以使用。
开启一个实例后，新建一个NoteBook,然后就可以进行下载的操作。
2.1 首先在文件最上面，输入以下的语句，进行所需依赖包的下载
%pip install numpy==2.2.4 pandas==2.2.3 netCDF4==1.7.2 lightgbm==4.6.0 scikit-learn==1.6.1
2.2 导入所需模块
from netCDF4 import Dataset
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import KFold
from sklearn.metrics import mean_squared_error
import lightgbm as lgb
from tqdm import tqdm
<3>竞赛具体分析流程
3.1 数据探索
数据探索性分析，是通过了解数据集，了解变量间的相互关系以及变量与预测值之间的关系，对已有数据在尽量少的先验假设下通过作图、制表、方程拟合、计算特征量等手段探索数据的结构和规律的一种数据分析方法，从而帮助我们后期更好地进行特征工程和建立模型，是机器学习中十分重要的一步。
数据分析大致工作可参考下图的常见流程：
-
数据观测
读取并查看训练集中气象数据
nc_path = "data/初赛训练集/nwp_data_train/1/NWP_1/20240101.nc"
dataset = Dataset(nc_path, mode='r')
dataset.variables.keys()
查看 channel 中变量，共有8个，具体如下
channel = dataset.variables["channel"][:]
channel
查看 data 维度，该数据维度为(1, 24, 8, 11, 11)
data = dataset.variables["data"][:]
data.shape
观测上步代码结果可知气象数据中新能源场站每个小时的数据维度为 2 （11x11），但构建模型对于单个时间点的单个特征只需要一个 标量 即可，因此我们把 11x11 个格点的数据取均值，从而将二维数据转为单一的标量值。
且主办方提供的气象数据时间精度为h，而发电功率精度为15min，即给我们一天的数据有24条天气数据与96（24*4）条功率数据，因此将功率数据中每四条数据只保留一条。
# 获取2024年日期
date_range = pd.date_range(start='2024-01-01', end='2024-12-30')
# 将%Y-%m-%d格式转为%Y%m%d
date = [date.strftime('%Y%m%d') for date in date_range]
# 定义读取训练/测试集函数
def get_data(path_template, date):
# 读取该天数据
dataset = Dataset(path_template.format(date), mode='r')
# 获取列名
channel = dataset.variables["channel"][:]
# 获取列名对应的数据
data = dataset.variables["data"][:]
# for i in range(8) 表示将第三维度进行遍历
# data[:, :, i, :, :][0] 的维度为(24, 11, 11)
# np.mean(data[:, :, i, :, :][0], axis=(1, 2) 表示对该数组的第二、三个维度(11, 11)计算均值 生成的列表长度为24
# 又因为循环了8次 因此形状为8*24
# 我们最后使用.T进行转置 将数组的维度转成了24*8
mean_values = np.array([np.mean(data[:, :, i, :, :][0], axis=(1, 2)) for i in range(8)]).T
# 将数据与列名整合为dataframe
return pd.DataFrame(mean_values, columns=channel)
# 定义路径模版
train_path_template = "/sdc/model/data/初赛训练集/nwp_data_train/1/NWP_1/{}.nc"
# 通过列表推导式获取数据 返回的列表中每个元素都是以天为单位的数据
data = [get_data(train_path_template, i) for i in date]
# 将每天的数据拼接并重设index
train = pd.concat(data, axis=0).reset_index(drop=True)
# 读取目标值
target = pd.read_csv("/sdc/model/data/初赛训练集/fact_data/1_normalization_train.csv")
target = target[96:]
# 功率数据中每四条数据去掉三条
target = target[target['时间'].str.endswith('00:00')]
target = target.reset_index(drop=True)
# 将目标值合并到训练集
train["power"] = target["功率(MW)"]
-
数据可视化
从分布中分析是否特征与特征、目标值之间存在周期性、趋势性、相关性和异常性。
特征工程
特征工程指的是把原始数据转变为模型训练数据的过程，目的是获取更好的训练数据特征。特征工程能使得模型的性能得到提升，有时甚至在简单的模型上也能取得不错的效果。
def feature_combine(df):
# 复制一份数据
df_copy = df.copy()
# 新增列风速 将两个方向的风速合并为总风速
df_copy["wind_speed"] = np.sqrt(df_copy['u100']**2 + df_copy['v100']**2)
# 添加小时的特征
df_copy["h"] = df_copy.index % 24
return df_copy
train = feature_combine(train)
数据清洗
数据和特征决定了机器学习的上限，而模型和算法只是逼近这个上限而已。俗话说：garbage in, garbage out。分析完数据后，特征工程前，必不可少的步骤是对数据清洗。
数据清洗的作用是利用有关技术如数理统计、数据挖掘或预定义的清理规则将脏数据转化为满足数据质量要求的数据。
baseline中没有进行细致的数据清洗工作，仅删除含有缺失值所在的行
train = train.dropna().reset_index(drop=True)
模型训练与验证
特征工程也好，数据清洗也罢，都是为最终的模型来服务的，模型的建立和调参决定了最终的结果。模型的选择决定结果的上限， 如何更好的去达到模型上限取决于模型的调参。
建模的过程需要我们对常见的线性模型、非线性模型有基础的了解。模型构建完成后，需要掌握一定的模型性能验证的方法和技巧
from sklearn.model_selection import KFold
from sklearn.metrics import mean_squared_error
import lightgbm as lgb
def cv_model(clf, train_x, train_y, test_x, seed=2024):
# 5折交叉验证
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 = []
# kf.split(train_x, train_y)返回一个生成器 每次调用返回新的train_index, valid_index
# 循环五次
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]
# 使用Lightgbm的Dataset构建训练及验证数据集
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': 'rmse',
# 子节点最小权重
'min_child_weight': 5,
# 最大叶子结点数
'num_leaves': 2 ** 8,
# L2正则化权重
'lambda_l2': 10,
# 每次迭代随机选择80%的特征
'feature_fraction': 0.8,
# 表示每次迭代随机选择80%的样本
'bagging_fraction': 0.8,
# 4次迭代执行一次bagging
'bagging_freq': 4,
# 学习率，即模型更新的幅度
'learning_rate': 0.1,
# 随机种子
'seed': 2023,
# 线程数
'nthread' : 16,
# 设置模型训练过程中不输出信息
'verbose' : -1,
}
# 使用参数训练模型
model = clf.train(params, train_matrix, 3000, valid_sets=[train_matrix, valid_matrix])
# 对验证集进行预测
val_pred = model.predict(val_x, num_iteration=model.best_iteration)
# 对测试集进行预测
test_pred = model.predict(test_x, num_iteration=model.best_iteration)
# 更新模型在验证集上的结果
oof[valid_index] = val_pred
# 将每个模型结果加权并相加
test_predict += test_pred / kf.n_splits
# 对rmse取倒数 得分越高性能越好
score = 1/(1+np.sqrt(mean_squared_error(val_pred, val_y)))
# 存储成绩
cv_scores.append(score)
# 打印成绩
print(cv_scores)
# 返回验证集及测试集结果
return oof, test_predict
test_path_template = "data/初赛测试集/nwp_data_test/1/NWP_1/{}.nc"
test_date_range = pd.date_range(start='2025-01-01', end='2025-01-31')
test_dates = [d.strftime('%Y%m%d') for d in test_date_range]
test_list = [get_data(test_path_template, dt) for dt in test_dates]
test = pd.concat(test_list, axis=0).reset_index(drop=True)
test = feature_combine(test).dropna().reset_index(drop=True)
# 获取训练集中除了power的其他列
cols = [f for f in train.columns if f not in ['power']]
test_x = test[cols]
# 使用函数
lgb_oof, lgb_test = cv_model(lgb, train[cols], train["power"], test_x)
# 将数据重复4次
lgb_test = [item for item in lgb_test for _ in range(4)]
结果输出
提交需要符合提交样例结果
# 读取数据
output = pd.read_csv("/sdc/model/data/output/output1.csv").reset_index(drop=True)
# 添加预测结果
output["power"] = lgb_test
# 重命名时间列
output.rename(columns={'Unnamed: 0': ''}, inplace=True)
# 将索引设置为时间列
output.set_index(output.iloc[:, 0], inplace=True)
# 删掉数据中名为 0 的列
output = output.drop(columns=["0", ""])
# 存储数据
output.to_csv('output/output1.csv')
进阶方法：
特征优化：
# 构建特征
def feature_combine(df):
df_copy = df.copy()
# 经纬度两个方向的风速进行向量计算 获取实际风速
df_copy["wind_speed"] = np.sqrt(df_copy['u100']**2 + df_copy['v100']**2)
# 添加小时特征 捕捉数据的时间周期性
df_copy["h"] = df_copy.index % 24
# 特征组合
# 计算ghi(水平面总辐照度)与poai(光伏面板辐照度)的比值
# 反映光伏组件的效率
df_copy["ghi/poai"] = df_copy["ghi"] / (df_copy["poai"] + 0.0000001)
# 同上
df_copy["ghi_poai"] = df_copy["ghi"] - df_copy["poai"]
# 计算总风速与sp(气压)的比值。有助于捕捉风速与气压之间的关系
df_copy["wind_speed/sp"] = df_copy["wind_speed"] / (df_copy["sp"] + 0.0000001)
return df_copy
模型融合：
def cv_model(clf, train_x, train_y, test_x, clf_name, seed = 2023):
'''
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, 2000, 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=2000, 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=2000, **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[cols], train["power"], test, 'lgb')
# 选择xgboost模型
xgb_oof, xgb_test = cv_model(xgb, train[cols], train["power"], test, 'xgb')
# 选择catboost模型
cat_oof, cat_test = cv_model(CatBoostRegressor, train[cols], train["power"], test, 'cat')
# 进行取平均融合
final_test = (lgb_test + xgb_test + cat_test) / 3
扫一扫
474
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
