使用神经网络预测光伏电站功率

TappaT

已于 2024-06-17 14:22:20 修改

阅读量2w

点赞数 63

分类专栏：人工智能文章标签： python 神经网络人工智能

于 2020-06-16 17:10:34 首次发布

本文链接：https://blog.csdn.net/TappaT/article/details/106791130

版权

人工智能专栏收录该内容

4 篇文章 13 订阅

订阅专栏

文章目录

1 前言

接了个机器学习的课题。初次尝试，花了一些时间，现在做完了打算简单总结一下。
先说一下做的课题，内容主要是使用神经网络模型预测光伏电站发电功率。输入数据是采用多个特征的多维度输入，之前看到很多人是做单个特征预测，也就是直接用先前的序列预测本身的下一个序列，这种就不太一样了。

用到的神经网络模型：BPNN、RNN、LSTM、Bi-LSTM。

以下给出的代码既不完整也不一定按顺序，仅供参考。
本篇主要是提供简单的思路。

2 准备工作

语言：Python

用的软件：Pycharm专业版+Anaconda，或者用Vscode自己搭环境也可以做。

神经网络框架：Pytorch。(顺带一提，自己用的轻薄本只有集显，所以Torch用的是无GPU加速的版本。)

其他用到的库：pandas, numpy, sklearn, matplotlib。

数据集来源：DKA太阳能中心，Desert Knowledge Australia Solar Centre，在数据下载里面有很多电站的数据，随便挑一个。([注] 该网站数据下载时会要求进行谷歌机器人验证，国内网络需要翻墙。)

3 流程

在这里插入图片描述

4 导入数据集

数据文件一般是csv或者xlsx格式，用pandas库直接导入，导入进来的数据这时是dataframe格式，有可能需要设置行列排序准则的参数，稍微注意一下。

按前面提供的那个数据，数据量比较多，就自己分割了一下，我还改了下样本名称之类的，其他可能还需要的一些小改动可参考这篇博文：从一份发电数据看组件Pr值衰减。

import pandas as pd

file_path = './91-Site_1A-Trina_5W.csv'
data = pd.read_csv(file_path, header=0, low_memory=False, index_col=0)
data = data.rename(columns={
    u'1A Trina - Active Energy Delivered-Received (kWh)': 'AE_Power',
    u'1A Trina - Current Phase Average (A)': 'Current', #电流
    u'1A Trina - Wind Speed (m/s)': 'Wind_speed',   #风速
    u'1A Trina - Active Power (kW)': 'Power',   #功率
    u'1A Trina - Weather Relative Humidity (%)': 'Humidity',    #湿度
    u'1A Trina - Weather Temperature Celsius (\xb0C)': 'Temp',    #气温
    u'1A Trina - Global Horizontal Radiation (W/m\xb2)': 'GHI',   #全球水平辐照度
    u'1A Trina - Diffuse Horizontal Radiation (W/m\xb2)': 'DHI',   #扩散水平辐照度
    u'1A Trina - Wind Direction (Degrees)': 'Wind_dir',  #风向
    u'1A Trina - Weather Daily Rainfall (mm)': 'Rainfall'   #降雨
})

5 相关性分析

原始数据提供的样本有很多，需要筛选出影响比较大的特征作为输入变量。

分析方法不只一种。

个人是直接用了.corr()函数来分析

print(data.corr()['Power'])

6 数据预处理

这个步骤看自己的需求和数据的情况，主要的工作量也体现在这。

对于缺失值，如果是null值的，一般是补零，否则后面处理时会报错。

异常值，用正态分布或者箱形图识别剔除。

我处理输入集时还把所有功率为0的样本都删了，不过这样似乎会影响时序关系，这个涉及模型特性问题，就不深入讨论了。

# 删除功率为空的数据组
data = data.dropna(subset=['Power'])
# NAN值赋0
data = data.fillna(0)
data[data < 0] = 0

标准化处理，必不可少，否则训练时的loss值降不下来。

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
data[feature] = scaler.fit_transform(data[feature].to_numpy())

另外，就是数据的格式，整个流程中需要经历dataframe $\rightarrow$ numpy $\rightarrow$ tensor的转换。

这里也给出我数据集输入前的最后转换，参考代码：

# 数据集调整，X转tensor，y转一维序列
def create_dataset(data, target_features, input_features):
    data_x = data[input_features]
    data_y = data[target_features]
    data_x = torch.from_numpy(data_x.to_numpy()).float()
    data_x = data_x.reshape(data_x.shape[0], 1, data_x.shape[1])
    data_y = torch.squeeze(torch.from_numpy(data_y.to_numpy()).float())
    return data_x, data_y

7 神经网络模型

Pytorch框架下，做时间序列的普通模型基本上就是调一些参数。

参考代码：

import torch
import torch.nn as nn
import torch.nn.functional as F

# LSTM模型
class LSTMNet(nn.Module):

    def __init__(self, input_size):
        super(LSTMNet, self).__init__()
        self.rnn = nn.LSTM(
            input_size=input_size,
            hidden_size=64,
            num_layers=1,
            batch_first=True,
        )
        self.out = nn.Sequential(
            nn.Linear(64, 1)
        )

    def forward(self, x):
        r_out, (h_n, h_c) = self.rnn(x, None)  # None 表示 hidden state 会用全0的 state
        out = self.out(r_out[:, -1, :])
        # print(out.shape)
        return out


# Bi-LSTM模型
class BiLSTMNet(nn.Module):

    def __init__(self, input_size):
        super(BiLSTMNet, self).__init__()
        self.rnn = nn.LSTM(
            input_size=input_size,
            hidden_size=50,
            num_layers=2,
            batch_first=True,
            bidirectional=True
        )
        self.out = nn.Sequential(
            nn.Linear(100, 1)
        )

    def forward(self, x):
        r_out, (h_n, h_c) = self.rnn(x, None)  # None 表示 hidden state 会用全0的 state
        out = self.out(r_out[:, -1, :])
        # print(out.shape)
        return out

# BP神经网络
class Net_BP(nn.Module):
    def __init__(self, n_features, n_hidden=50, n_output=1):
        # n_features输入层神经元数量，也就是特征数量
        # n_hidden隐层神经元数量
        # n_output输出层神经元数量
        super(Net_BP, self).__init__()
        self.hidden = torch.nn.Linear(n_features, n_hidden)
        self.predict = torch.nn.Linear(n_hidden, n_output)

    def forward(self, x):
        x = F.relu(self.hidden(x))
        x = self.predict(x)
        return x


# RNN神经网络
class RNN(nn.Module):
    def __init__(self, input_size, hidden_size=50, output_size=1, num_layers=1):
        super(RNN, self).__init__()
        self.rnn = nn.RNN(input_size, hidden_size, num_layers)
        self.reg = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x, _ = self.rnn(x) # 未在不同序列中传递hidden_state
        return self.reg(x)

8 模型训练

这里以RNN模型为例子。

参考代码：

rnn = RNN(input_size=input_feature_num)
optimizer = torch.optim.Adam(rnn.parameters(), lr=0.01)
loss_func = nn.MSELoss()
epochs = 100
print(rnn)

for e in range(epochs):
    # 前向传播
    y_pred = rnn(train_x)
    y_pred = torch.squeeze(y_pred)
    loss = loss_func(y_pred, train_y)
    # 反向传播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if e % 20 == 0:
        print('Epoch:{}, Loss:{:.5f}'.format(e, loss.item()))

plt.plot(y_pred.detach().numpy(), 'r', label='y_pred')
plt.plot(train_y.detach().numpy(), 'b', label='y_train')
plt.legend()
plt.show()

训练完没问题的话还要记得保存模型。

参考代码：

MODEL_PATH = 'model_rnn.pth'
torch.save(rnn, MODEL_PATH)

这里我是直接保存了整个模型，有人说保存模型参数的方法会更好，这个就看个人需求了。

9 模型测试

测试用的数据集同样是经过之前的方式处理，然后要注意训练集与测试集的样本数量比例。一般是设为10：1左右。

模型性能使用几个评价指标来评定，我选用了MSE、RMSE、MAE和 $R^2$ ，这四个指标，因为考虑到一些零值保留的问题，就没有使用MAPE。

参考代码：

from sklearn.metrics import mean_squared_error
from sklearn.metrics import r2_score
from sklearn.metrics import  mean_absolute_error

def prediction(model, series_x, series_y, name):
    model = model.eval()
    pred = model(series_x)
    pred[pred < 0] = 0
    length = len(series_y)
    for i in range(length):
        if series_y[i] == 0:
            pred[i] = 0
    pred = pred.view(-1).data.numpy()
    pred = y_scaler.inverse_transform(pred.reshape(-1, 1))
    series_y = y_scaler.inverse_transform(series_y.reshape(-1, 1))
    MSE = mean_squared_error(series_y, pred)
    RMSE = sqrt(MSE)
    R2 = r2_score(series_y, pred)
    MAE = mean_absolute_error(series_y, pred)
    # MAPE = method.MAPE_value(series_y, pred)
    print(name, ' :')
    print(' MSE: {:.3f}'.format(MSE))
    print(' RMSE: {:.3f}'.format(RMSE))
    print(' MAE: {:.3f}'.format(MAE))
    print(' R2: {:.3f}'.format(R2))
    # print(' MAPE: {:.5f}%'.format(MAPE))
    return pred

测试运行和画图部分就不说了，值得一提的是反归一化这步也要有，不然测试出来的误差明显是小得有问题的。

参考代码：

test_y = y_scaler.inverse_transform(test_y.reshape(-1, 1))

直接调用库很方便，但是要注意这里的反归一化是对应前面的归一化，要在同一文件里。

10 结果

没做样本分类等优化，所以结果不算很好，仅供参考。

预测时间跨度大概72小时：

附录

该实验初版完整代码已在github开源：https://github.com/tappat225/PV_prediction

TappaT

关注

63
点赞
踩
441

收藏

觉得还不错? 一键收藏
45
评论
使用神经网络预测光伏电站功率

接了个机器学习的课题。初次尝试，花了一些时间，现在做完了打算简单总结一下。先说一下做的课题，内容主要是使用神经网络模型预测光伏电站发电功率。输入数据是采用多个特征的多维度输入，之前看到很多人是做单个特征预测，也就是直接用先前的序列预测本身的下一个序列，这种就不太一样了。用到的神经网络模型：BPNN、RNN、LSTM、Bi-LSTM。以下给出的代码既不完整也不一定按顺序，仅供参考。本篇主要是提供简单的思路。
复制链接

扫一扫