前言

1-1 简介

DataFountain平台举办的比赛，赛题：光伏电站人工智能运维大数据处理分析。以下是比赛链接：光伏电站人工智能运维大数据处理分析 Competitions - DataFountain

1-2 任务背景

在分析光伏发电原理的基础上，论证了辐照度、光伏板工作温度等影响光伏输出功率的因素，通过实时监测的光伏板运行状态参数和气象参数建立预测模型，预估光伏电站瞬时发电量。其中光伏板运行状态参数包括太阳能电池板背板温度、其组成的光伏阵列的电压和电流；气象参数包括太阳能辐照度、环境温湿度、风速、风向等。本质为回归任务，通过多个维度的X去预测发电量Y。

1-3 数据介绍

其中比赛官网给出了各个字段的详细介绍；

表格字段及含义如下：
  ID:当前记录条数； 
  板温：光伏电池板背测温度；
  现场温度：光伏电站现场温度；
  转换效率：为计算得到的平均转换效率；
  转换效率A：数据采集点A处的光伏板转换效率；
  转换效率B：数据采集点B处的光伏板转换效率；
  转换效率C：数据采集点C处的光伏板转换效率；
  转换效率D：数据采集点D处的光伏板转换效率；
  电压A：为数据采集点A处汇流箱电压值；
  电压B：为数据采集点B处汇流箱电压值；
  电压C：为数据采集点C处汇流箱电压值；
  电压D：为数据采集点D处汇流箱电压值；
  电流A：为采集点A处汇流箱电流值；
  电流B：为采集点B处汇流箱电流值；
  电流C：为采集点C处汇流箱电流值；
  电流D：为采集点D处汇流箱电流值；
  功率A：为采集点A处的功率Pa，P=UI；
  功率B：为采集点B处的功率Pb，P=UI；
  功率C：为采集点C处的功率Pc，P=UI；
  功率D：为采集点D处的功率Pd，P=UI；
  平均功率：为A、B、C三点功率的平均值：(Pa+Pb+Pc)/3;
  风速：为光伏电厂现场风速测量值；
  风向：为光伏电厂现场风的来向；
  预估发电量为：需经过参赛者分析计算得到的预测功率值；

2 任务实现

2-1 深度学习-多元线性回归

赛题任务是根据多个自变量X(板温、温度等) 来确定唯一的因变量Y(光伏发电量)，非常典型的多元线性回归任务。多元回归任务的公式如下：

$y = {k_{1}} x_{1}+ {k_{2}} x_{2}+ {k_{3}} x_{3}+ ...+{k_{n}} x_{n}+ b$

2-1-1 导入工具库

import pandas as pd
import numpy as np
import torch 
import torch.nn
from sklearn.preprocessing import scale
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from matplotlib.font_manager import FontProperties

2-1-2 查看数据

train_data_path = '/home/zhenhengdong/WORk/Relation_Extraction/Jupyter_files/Codes/Untitled Folder/public.train.csv'
Train_data = pd.read_csv(train_data_path)
test_data_path = '/home/zhenhengdong/WORk/Relation_Extraction/Jupyter_files/Codes/Untitled Folder/test_data.csv'
Test_data = pd.read_csv(test_data_path)

2-1-3 读入数据

采用np.loadtxt()方法读入数据。原始数据中每一行包含20个维度的X与一个Y，将X和Y进行分割。

#跳过表头，并且设置数据格式
train_XY  = np.loadtxt(train_data_path, delimiter=',', skiprows = 1,dtype=np.float32)
test_XY = np.loadtxt(test_data_path, delimiter=',', skiprows = 1,dtype=np.float32)

#分割多维度X和Y
TrainX_data = torch.from_numpy(train_XY[:, 1:-1])# 除去id后 取前20列 
TrainY_data = torch.from_numpy(train_XY[:, [-1]])# 取最后1列

TestX_data = torch.from_numpy(test_XY[:, 1:-1])# 除去id后 取前20列 
TestY_data = torch.from_numpy(test_XY[:, [-1]])# 取最后1列

2-1-4 数据归一化

#归一化
TrainX_data, TrainY_data = torch.FloatTensor(scale(TrainX_data)), torch.unsqueeze(torch.FloatTensor(TrainY_data), dim=1)
#归一化
TestX_data, TestY_data = torch.FloatTensor(scale(TestX_data)), torch.unsqueeze(torch.FloatTensor(TestY_data), dim=1)

2-1-5 定义模型结构

由于是多元线性回归任务，在模型定义中采用线性层和激活函数搭配的方式进行构建。其中采用Relu()函数作为激活函数。激活函数可以设定设定了一个中间层hidden_num。

class Net(torch.nn.Module):
    def __init__(self, input_num, hidden_num, output_num):
        super(Net, self).__init__()
        self.net = torch.nn.Sequential(
            torch.nn.Linear(input_num, hidden_num),
            torch.nn.ReLU(),
            torch.nn.Linear(hidden_num, output_num),
            torch.nn.ReLU()
        )
    def forward(self, input):
        return self.net(input)

2-1-6 实例化模型

模型实例化中，将输入维度设定为19，采用了数据中的19的维度（除去设备id），中间层进行过渡，将19维度的信息转换为10维度，并采用激活函数进行变换，最后将10维度的数据转换为1维。

net = Net(input_num=19, hidden_num=10, output_num=1)

2-1-7 设置超参数

epochs = 500
learning_rate = 0.001
batch_size = 10
total_step = int(TrainX_data.shape[0] / batch_size)

2-1-8 定义优化器与损失函数

采用Adam优化器，Adam优化器结合了AdaGrad和RMSProp两种优化算法的优点。对梯度的一阶矩估计（First Moment Estimation，即梯度的均值）和二阶矩估计（Second Moment Estimation，即梯度的未中心化的方差）进行综合考虑，计算出更新步长

损失函数测量输入x和目标y中每个元素之间的均方误差。

optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)
loss_func = torch.nn.MSELoss()

2-1-9 定义参数重置函数

保证每次重新执行for循环时从零开始训练。

def weight_reset(m):
    if isinstance(m, torch.nn.Conv2d) or isinstance(m, torch.nn.Linear):
        m.reset_parameters()

2-1-10 开始训练

%%time
net.apply(weight_reset)
epoch_train_loss_value = []
step_train_loss_value = []
epoch_valid_loss_value = []

for i in range(epochs):
    for step in range(total_step):
        xs = TrainX_data[step * batch_size:(step + 1) * batch_size, :]
        ys = TrainY_data[step * batch_size:(step + 1) * batch_size]
        prediction = net(xs)
        loss = loss_func(prediction, ys)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        step_train_loss_value.append(loss.cpu().detach().numpy())
    valid_loss = loss_func(net(TestX_data), TestY_data)
    epoch_valid_loss_value.append(valid_loss)
    epoch_train_loss_value.append(np.mean(step_train_loss_value))
    if i%50==0:
        print('epoch={:3d}/{:3d}, train_loss={:.4f}, valid_loss={:.4f}'.format(i + 1,
                                                                    epochs,
                                                                    np.mean(step_train_loss_value),
                                                                    valid_loss))

2-1-11 损失值可视化

new_epoch_valid_loss_value = []
for valid_loss_item in epoch_valid_loss_value:
    new_epoch_valid_loss_value.append(valid_loss_item.detach().numpy().tolist())
#画图
fig = plt.gcf()
fig.set_size_inches(10, 5)

plt.xlabel('Epochs', fontsize=15)
plt.ylabel('Loss', fontsize=15)
plt.plot(epoch_train_loss_value, 'blue', label='Train loss')
plt.plot(new_epoch_valid_loss_value, 'red', label='Valid loss')
plt.legend(loc='best')
plt.title('Training and Validation loss', fontsize=15)
plt.show()

2-1-12 模型预测可视化

#生成预测值
prediction = []
for i in range(TestX_data.shape[0]):
    prediction.append(net(TestX_data[i, :]).item())
#对真实值处理，由Tensor转化为list
new_TestY_data = []
for TestY_data_item in TestY_data:
    new_TestY_data.append(TestY_data_item.detach().numpy().tolist()[0][0][0])
#画图
fig = plt.gcf()
fig.set_size_inches(10, 5)

myfont = FontProperties('SimSun')

plt.title('Prediction and GroundTruth', fontproperties=myfont, fontsize=15)
plt.scatter(np.arange(len(prediction)), prediction, label='Prediction', s=20)
plt.scatter(np.arange(len(prediction)), new_TestY_data, label='GroundTruth', s=20)
plt.xlabel('', fontproperties=myfont, fontsize=15)
plt.ylabel('Power generation', fontproperties=myfont, fontsize=15)
plt.legend()
plt.show()

2-1-13 计算方差得分

from sklearn.metrics import explained_variance_score
score = explained_variance_score(prediction, new_TestY_data)

2-2 机器学习-xgboost

XGBoost(eXtreme Gradient Boosting)又叫极度梯度提升树，是boosting算法的一种实现方式。针对分类或回归问题，有非常好的效果。

2-2-1 导入工具库

import xgboost as xgb
from sklearn.metrics import explained_variance_score

2-2-2 导入数据

train_XY  = np.loadtxt(train_data_path, delimiter=',', skiprows = 1,dtype=np.float32)
test_XY = np.loadtxt(test_data_path, delimiter=',', skiprows = 1,dtype=np.float32)
TrainX_data = torch.from_numpy(train_XY[:, 1:-1])# 除去id后 取前20列 
TrainY_data = torch.from_numpy(train_XY[:, [-1]])# 取最后1列

TestX_data = torch.from_numpy(test_XY[:, 1:-1])# 除去id后 取前20列 
TestY_data = torch.from_numpy(test_XY[:, [-1]])# 取最后1列

2-2-3 构建模型

参数详解

max_depth=3	每一棵树最大深度，默认6；
learning_rate=0.1	学习率，每棵树的预测结果都要乘以这个学习率，默认0.3；
n_estimators=100	使用多少棵树来拟合，也可以理解为多少次迭代。默认100；
objective='reg:linear'	此默认参数与 XGBClassifier 不同；
booster='gbtree'	有两种模型可以选择gbtree和gblinear。gbtree使用基于树的模型进行提升计算，gblinear使用线性模型进行提升计算。默认为gbtree；
gamma=0	# 叶节点上进行进一步分裂所需的最小"损失减少"。默认0；
min_child_weight=1	可以理解为叶子节点最小样本数，默认1；
subsample=1	训练集抽样比例，每次拟合一棵树之前，都会进行该抽样步骤。默认1，取值范围(0, 1]；
subsample=1	训练集抽样比例，每次拟合一棵树之前，都会进行该抽样步骤。默认1，取值范围(0, 1]；
colsample_bytree=1	每次拟合一棵树之前，决定使用多少个特征，参数默认1，取值范围(0, 1]；
reg_alpha=0	默认为0，控制模型复杂程度的权重值的 L1 正则项参数，参数值越大，模型越不容易过拟合；
reg_lambda=1	默认为1，控制模型复杂度的权重值的L2正则化项参数，参数越大，模型越不容易过拟合；
random_state=0)	随机种子；

model = xgb.XGBRegressor(max_depth=3,          # 每一棵树最大深度，默认6；
                        learning_rate=0.1,      # 学习率，每棵树的预测结果都要乘以这个学习率，默认0.3；
                        n_estimators=100,        # 使用多少棵树来拟合，也可以理解为多少次迭代。默认100；
                        objective='reg:linear',   # 此默认参数与 XGBClassifier 不同
                        booster='gbtree',         # 有两种模型可以选择gbtree和gblinear。gbtree使用基于树的模型进行提升计算，gblinear使用线性模型进行提升计算。默认为gbtree
                        gamma=0,                 # 叶节点上进行进一步分裂所需的最小"损失减少"。默认0；
                        min_child_weight=1,      # 可以理解为叶子节点最小样本数，默认1；
                        subsample=1,              # 训练集抽样比例，每次拟合一棵树之前，都会进行该抽样步骤。默认1，取值范围(0, 1]
                        colsample_bytree=1,       # 每次拟合一棵树之前，决定使用多少个特征，参数默认1，取值范围(0, 1]。
                        reg_alpha=0,             # 默认为0，控制模型复杂程度的权重值的 L1 正则项参数，参数值越大，模型越不容易过拟合。
                        reg_lambda=1,            # 默认为1，控制模型复杂度的权重值的L2正则化项参数，参数越大，模型越不容易过拟合。
                        random_state=0)           # 随机种子model.fit(TrainX_data,TrainY_data)
test_predict=model.predict(TestX_data)
train_predict = model.predict(TrainX_data)

2-2-4 计算方差得分

2-2-5 查看重要特征

from xgboost import plot_importance
plot_importance(model)
plt.show()

2-2-6 模型预测可视化

new_TestY_data = []
for TestY_data_item in TestY_data:
    new_TestY_data.append(TestY_data_item.detach().numpy().tolist()[0])
#画图
fig = plt.gcf()
fig.set_size_inches(10, 5)

myfont = FontProperties('SimSun')

plt.title('Prediction and GroundTruth', fontproperties=myfont, fontsize=15)
plt.scatter(np.arange(len(new_TestY_data)), test_predict.tolist(), label='Prediction', s=20)
plt.scatter(np.arange(len(new_TestY_data)), new_TestY_data, label='GroundTruth', s=20)
plt.xlabel('', fontproperties=myfont, fontsize=15)
plt.ylabel('Power generation', fontproperties=myfont, fontsize=15)
plt.legend()
plt.show()