# -*- coding: utf-8 -*-
|
"""
|
Created on Fri May 24 15:33:12 2024
|
|
@author: BDYGS
|
"""
|
|
# -*- coding: utf-8 -*-
|
"""
|
Created on Tue Apr 23 05:28:13 2024
|
|
@author: BDYGS
|
"""
|
|
# -*- coding: utf-8 -*-
|
"""
|
Created on Sat Apr 6 04:01:04 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
|
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 # 学习率
|
|
|
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_data(x,y,split_ratio):
|
|
train_size=int(len(y)*split_ratio)
|
test_size=len(y)-train_size
|
|
x_data=Variable(torch.Tensor(np.array(x)))
|
y_data=Variable(torch.Tensor(np.array(y)))
|
|
x_train=Variable(torch.Tensor(np.array(x[0:train_size])))
|
y_train=Variable(torch.Tensor(np.array(y[0:train_size])))
|
y_test=Variable(torch.Tensor(np.array(y[train_size:len(y)])))
|
x_test=Variable(torch.Tensor(np.array(x[train_size:len(x)])))
|
|
print('x_data.shape,y_data.shape,x_train.shape,y_train.shape,x_test.shape,y_test.shape:\n{}{}{}{}{}{}'
|
.format(x_data.shape,y_data.shape,x_train.shape,y_train.shape,x_test.shape,y_test.shape))
|
|
return x_data,y_data,x_train,y_train,x_test,y_test
|
|
|
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)
|
|
|
|
# 1.加载时间序列数据
|
|
df= pd.read_csv(config.data_path,parse_dates=["date"],index_col=[0])
|
#parse_dates将该列视为时间索引
|
|
print(df.shape)
|
|
data = df.iloc[:,0:8] # 以特征作为数据
|
label = df.iloc[:,7]
|
data = data.values
|
label = label.values.reshape(-1,1)
|
|
# torch.manual_seed(7) #设置生成随机数的种子，以保证代码的可重复性
|
|
data,label,mm_y=normalization(data,label)
|
|
dataX,dataY = split_windows(data,config.timestep,config.output_size)
|
|
x_data,y_data,x_train,y_train,x_test,y_test = split_data(dataX,dataY,0.8)
|
|
# 5.形成训练数据集
|
train_data = TensorDataset(x_train,y_train)
|
test_data = TensorDataset(x_test,y_test)
|
|
|
# 6.将数据加载成迭代器
|
train_loader = torch.utils.data.DataLoader(train_data,
|
config.batch_size,
|
False)
|
|
test_loader = torch.utils.data.DataLoader(test_data,
|
config.batch_size,
|
False)
|
|
|
# 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) # 定义优化器
|
|
# 8.模型训练
|
for epoch in range(config.epochs):
|
model.train()
|
running_loss = 0
|
train_bar = tqdm(train_loader) # 形成进度条
|
for data in train_bar:
|
x_train, y_train = data # 解包迭代器中的X和Y
|
optimizer.zero_grad()
|
y_train_pred = model(x_train)
|
|
loss = loss_function(y_train_pred, y_train)
|
loss.backward()
|
optimizer.step()
|
|
running_loss += loss.item()
|
train_bar.desc = "train epoch[{}/{}] loss:{:.6f}".format(epoch + 1,
|
config.epochs,
|
loss)
|
|
print('Finished Training')
|
|
model_name = 'GRU_YQS'
|
torch.save(model.state_dict(), 'C://Users//ZMK//Desktop//GRU/{}.pth'.format(model_name))
|
|
|
model.eval()
|
|
#模型验证：用原始数据再算一次
|
|
df= pd.read_csv(config.data_path,parse_dates=["date"],index_col=[0])
|
#parse_dates将该列视为时间索引
|
|
data = df.iloc[:,0:8] # 以四个特征作为数据
|
label = df.iloc[:,7]
|
data = data.values
|
label = label.values.reshape(-1,1)
|
|
|
data,label,mm_y=normalization(data,label)
|
|
dataX,dataY = split_windows(data,config.timestep,config.output_size)
|
|
x_data,y_data,x_train,y_train,x_test,y_test = split_data(dataX,dataY,0.8)
|
|
test_pre = model(x_data)
|
|
with pd.ExcelWriter("C:\\Users\\ZMK\\Desktop\\GRU\GRU-YQS.xlsx", engine='openpyxl') as writer:
|
|
for i in range(6):
|
test_pre_data = test_pre[:,0,i].data.numpy().reshape(-1,1)
|
y_test_pre = y_data[:,0,i].data.numpy().reshape(-1,1)
|
|
print(test_pre_data.shape)
|
|
test_pre_data_inv = mm_y.inverse_transform(test_pre_data)
|
|
# print(test_pre_data_inv.shape)
|
y_test_inv =mm_y.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'test 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'test Node {i+1}', index=False)
|
