# -*- coding: utf-8 -*-
|
"""
|
Created on Sun May 26 02:15:11 2024
|
|
@author: BDYGS
|
"""
|
|
|
import matplotlib.pyplot as plt
|
import numpy as np
|
import pandas as pd
|
import torch
|
import torch.nn as nn
|
from torch.autograd import Variable
|
# import tushare as ts
|
from sklearn.preprocessing import StandardScaler, MinMaxScaler
|
from sklearn.metrics import mean_squared_error
|
from sklearn.metrics import mean_absolute_error
|
from torch.utils.data import TensorDataset
|
from tqdm import tqdm
|
|
|
|
|
class Config():
|
# data_path = "C:\\Users\\ZMK\\Desktop\\GRU\永定河井.csv"
|
timestep = 60 # 时间步长，就是利用多少时间窗口
|
batch_size = 30 # 批次大小
|
feature_size = 8 # 每个步长对应的特征数量，这里只使用1维，每天的风速
|
hidden_size = 256 # 隐层大小
|
output_size = 15 # 由于是单输出任务，最终输出层大小为1，预测未来1天风速
|
num_layers = 2 # gru的层数
|
epochs = 100 # 迭代轮数
|
best_loss = 0 # 记录损失
|
learning_rate = 0.0003 # 学习率
|
# model_name = 'GRU_ZMK' # 模型名称
|
# save_path = 'C://Users//ZMK//Desktop//GRU//{}.pth'.format(model_name) # 最优模型保存路径
|
|
config = Config()
|
|
|
def normalization(data,label):
|
mm_x=MinMaxScaler() # 导入sklearn的预处理容器
|
mm_y=MinMaxScaler()
|
data=mm_x.fit_transform(data) # 对数据和标签进行归一化等处理
|
label=mm_y.fit_transform(label)
|
return data,label,mm_y
|
|
|
def split_windows(data,seq_len,output_size):
|
x=[]
|
y=[]
|
for i in range(len(data)-seq_len-1-output_size): # range的范围需要减去时间步长和1
|
_x=data[i:(i+seq_len),:]
|
_y=data[(i+seq_len):(i+seq_len+output_size),2:] #注意！！！这个地方是取label的
|
|
x.append(_x)
|
y.append(_y)
|
print('split_windows_i:',i)
|
print(_x.shape,_y.shape)
|
x,y=np.array(x),np.array(y)
|
print('x.shape,y.shape=\n',x.shape,y.shape)
|
return x,y
|
|
def split_windows_long(data,seq_len,output_size):
|
|
print(len(data))
|
x=[]
|
y=[]
|
for i in range(int(len(data)/output_size)-4):
|
a = i*output_size
|
# print(a)
|
_x=data[a:a+seq_len,:]
|
# print(_x.shape)
|
_y=data[a+seq_len:a+seq_len+output_size,2:] #注意！！！这个地方是取label的
|
# print(_y.shape)
|
x.append(_x)
|
y.append(_y)
|
print('split_windows_i:',i)
|
# print(_x,_y)
|
x,y=np.array(x),np.array(y)
|
print('x.shape,y.shape=\n',x.shape,y.shape) # (1035, 60, 4) (1035,)
|
return x,y
|
|
|
def nash_sutcliffe_efficiency(y_true, y_pred):
|
"""
|
计算Nash-Sutcliffe Efficiency指标。
|
参数:
|
y_true : array-like, 真实观测值
|
y_pred : array-like, 预测值
|
返回:
|
nse : float, Nash-Sutcliffe Efficiency
|
"""
|
return 1 - np.sum((y_true - y_pred)**2) / np.sum((y_true - np.mean(y_true))**2)
|
|
|
|
# 7.定义GRU网络
|
class GRU(nn.Module):
|
def __init__(self, feature_size, hidden_size, num_layers, output_size):
|
super(GRU, self).__init__()
|
self.hidden_size = hidden_size
|
self.output_size = output_size
|
# 隐层大小
|
self.num_layers = num_layers # gru层数
|
# feature_size为特征维度，就是每个时间点对应的特征数量，这里为1
|
self.gru = nn.GRU(feature_size, hidden_size, num_layers, dropout=0.8,batch_first=True)
|
self.fc1 = nn.Linear(self.hidden_size, self.output_size)
|
self.fc2 = nn.Linear(self.hidden_size, self.output_size)
|
self.fc3 = nn.Linear(self.hidden_size, self.output_size)
|
self.fc4 = nn.Linear(self.hidden_size, self.output_size)
|
self.fc5 = nn.Linear(self.hidden_size, self.output_size)
|
self.fc6 = nn.Linear(self.hidden_size, self.output_size)
|
|
def forward(self, x, hidden=None):
|
batch_size = x.size()[0] # 获取批次大小
|
|
# 初始化隐层状态
|
if hidden is None:
|
h_0 = x.data.new(self.num_layers, batch_size, self.hidden_size).fill_(0).float()
|
else:
|
h_0 = hidden
|
|
# GRU运算
|
output, h_0 = self.gru(x, h_0)
|
|
# 获取GRU输出的维度信息
|
batch_size, timestep, hidden_size = output.shape
|
|
# 将output变成 batch_size * timestep, hidden_dim
|
# output = output.reshape(-1, hidden_size)
|
|
preds = []
|
pred1, pred2, pred3 = self.fc1(output), self.fc2(output), self.fc3(output)
|
pred1, pred2, pred3 = pred1[:, -1, :], pred2[:, -1, :], pred3[:, -1, :]
|
pred4, pred5, pred6 = self.fc4(output), self.fc5(output), self.fc6(output)
|
pred4, pred5, pred6 = pred4[:, -1, :], pred5[:, -1, :], pred6[:, -1, :]
|
pred = torch.stack([pred1, pred2, pred3,pred4, pred5, pred6], dim=2)
|
|
return pred
|
|
model = GRU(config.feature_size, config.hidden_size, config.num_layers, config.output_size) # 定义GRU网络
|
print(model)
|
loss_function = nn.MSELoss() # 定义损失函数
|
optimizer = torch.optim.AdamW(model.parameters(), lr=config.learning_rate) # 定义优化器
|
|
#
|
model.load_state_dict(torch.load('C://Users//ZMK//Desktop//GRU//GRU_YDH.pth'))
|
|
|
model.eval()
|
#pre
|
|
df_pre = pd.read_csv("C:\\Users\\ZMK\\Desktop\\GRU\\永定河井-pre.csv",parse_dates=["date"],index_col=[0])
|
|
print(df_pre.shape)
|
|
data_pre = df_pre.iloc[:,0:8]
|
|
label_pre = df_pre.iloc[:,7] #label没有实际作用，主要用作正则化缩放的，不参与计算
|
|
|
data_pre = data_pre.values
|
|
label_pre = label_pre.values.reshape(-1,1)
|
|
data_pre,label_pre,mm_y_pre = normalization(data_pre,label_pre)
|
dataX_pre,dataY_pre = split_windows_long(data_pre,config.timestep,config.output_size)
|
|
dataX_pre = Variable(torch.Tensor(np.array(dataX_pre)))
|
dataY_pre = Variable(torch.Tensor(np.array(dataY_pre)))
|
|
print(dataY_pre.shape)
|
|
test_pre = model(dataX_pre)
|
|
print(test_pre.shape)
|
|
|
|
|
with pd.ExcelWriter("C:\\Users\\ZMK\\Desktop\\GRU\\GRU-pre-ydh.xlsx", engine='openpyxl') as writer:
|
|
for i in range(6):
|
test_pre_data = test_pre[:,:,i].data.numpy().reshape(-1,1)
|
y_test_pre = dataY_pre[:,:,i].data.numpy().reshape(-1,1)
|
|
test_pre_data_inv = mm_y_pre.inverse_transform(test_pre_data)
|
y_test_inv =mm_y_pre.inverse_transform(y_test_pre)
|
|
|
# plt.figure(figsize=(10,5))
|
# plt.plot(y_test_inv)
|
# plt.plot(test_pre_data_inv)
|
# plt.legend(('real', 'predict'),fontsize='15')
|
# plt.show()
|
|
print('MAE/RMSE/NSE')
|
print(mean_absolute_error(y_test_inv, test_pre_data_inv))
|
print(np.sqrt(mean_squared_error(y_test_inv, test_pre_data_inv)))
|
print(nash_sutcliffe_efficiency(y_test_inv, test_pre_data_inv))
|
|
y_test_inv = pd.DataFrame(y_test_inv, columns=[f'True Node {i+1}'])
|
test_pre_data_inv = pd.DataFrame(test_pre_data_inv, columns=[f'pre Node {i+1}'])
|
|
# 将结果保存到不同的工作表中
|
test_pre_data_inv.to_excel(writer, sheet_name=f'True Node {i+1}', index=False)
|
y_test_inv.to_excel(writer, sheet_name=f'pre Node {i+1}', index=False)
|
|
|
