PyTorch搭建LSTM實現(xiàn)多變量時序負荷預(yù)測

第PyTorch搭建LSTM實現(xiàn)多變量時序負荷預(yù)測目錄I.前言II.數(shù)據(jù)處理III.LSTM模型IV.訓練V.測試VI.源碼及數(shù)據(jù)

I.前言

在前面的一篇文章PyTorch搭建LSTM實現(xiàn)時間序列預(yù)測（負荷預(yù)測）中，我們利用LSTM實現(xiàn)了負荷預(yù)測，但我們只是簡單利用負荷預(yù)測負荷，并沒有利用到其他一些環(huán)境變量，比如溫度、濕度等。

本篇文章主要考慮用PyTorch搭建LSTM實現(xiàn)多變量時間序列預(yù)測。

系列文章：

PyTorch搭建LSTM實現(xiàn)多變量多步長時序負荷預(yù)測

PyTorch深度學習LSTM從input輸入到Linear輸出

PyTorch搭建LSTM實現(xiàn)時間序列負荷預(yù)測

PyTorch搭建雙向LSTM實現(xiàn)時間序列負荷預(yù)測

II.數(shù)據(jù)處理

數(shù)據(jù)集為某個地區(qū)某段時間內(nèi)的電力負荷數(shù)據(jù)，除了負荷以外，還包括溫度、濕度等信息。

本文中，我們根據(jù)前24個時刻的負荷以及該時刻的環(huán)境變量來預(yù)測下一時刻的負荷。

defload_data(file_name):

globalMAX,MIN

df=pd.read_csv(os.path.dirname(os.getcwd())+'/data/new_data/'+file_name,encoding='gbk')

columns=df.columns

df.fillna(df.mean(),inplace=True)

MAX=np.max(df[columns[1]])

MIN=np.min(df[columns[1]])

df[columns[1]]=(df[columns[1]]-MIN)/(MAX-MIN)

returndf

classMyDataset(Dataset):

def__init__(self,data):

self.data=data

def__getitem__(self,item):

returnself.data[item]

def__len__(self):

returnlen(self.data)

defnn_seq(file_name,B):

print('處理數(shù)據(jù):')

data=load_data(file_name)

load=data[data.columns[1]]

load=load.tolist()

data=data.values.tolist()

seq=[]

foriinrange(len(data)-24):

train_seq=[]

train_label=[]

forjinrange(i,i+24):

x=[load[j]]

forcinrange(2,8):

x.append(data[j][c])

train_seq.append(x)

train_label.append(load[i+24])

train_seq=torch.FloatTensor(train_seq)

train_label=torch.FloatTensor(train_label).view(-1)

seq.append((train_seq,train_label))

#print(seq[:5])

Dtr=seq[0:int(len(seq)*0.7)]

Dte=seq[int(len(seq)*0.7):len(seq)]

train_len=int(len(Dtr)/B)*B

test_len=int(len(Dte)/B)*B

Dtr,Dte=Dtr[:train_len],Dte[:test_len]

train=MyDataset(Dtr)

test=MyDataset(Dte)

Dtr=DataLoader(dataset=train,batch_size=B,shuffle=False,num_workers=0)

Dte=DataLoader(dataset=test,batch_size=B,shuffle=False,num_workers=0)

returnDtr,Dte

上面代碼用了DataLoader來對原始數(shù)據(jù)進行處理，最終得到了batch_size=B的數(shù)據(jù)集Dtr和Dte，Dtr為訓練集，Dte為測試集。

任意輸出Dte中的一條數(shù)據(jù)：

[(tensor([[0.3513,0.0000,0.9091,0.0000,0.6667,0.3023,0.2439],

[0.3333,0.0000,0.9091,0.0435,0.6667,0.3023,0.2439],

[0.3396,0.0000,0.9091,0.0870,0.6667,0.3023,0.2439],

[0.3427,0.0000,0.9091,0.1304,0.6667,0.3023,0.2439],

[0.3838,0.0000,0.9091,0.1739,0.6667,0.3023,0.2439],

[0.3700,0.0000,0.9091,0.2174,0.6667,0.3023,0.2439],

[0.4288,0.0000,0.9091,0.2609,0.6667,0.3023,0.2439],

[0.4474,0.0000,0.9091,0.3043,0.6667,0.3023,0.2439],

[0.4406,0.0000,0.9091,0.3478,0.6667,0.3023,0.2439],

[0.4657,0.0000,0.9091,0.3913,0.6667,0.3023,0.2439],

[0.4540,0.0000,0.9091,0.4348,0.6667,0.3023,0.2439],

[0.4939,0.0000,0.9091,0.4783,0.6667,0.3023,0.2439],

[0.4328,0.0000,0.9091,0.5217,0.6667,0.3023,0.2439],

[0.4238,0.0000,0.9091,0.5652,0.6667,0.3023,0.2439],

[0.4779,0.0000,0.9091,0.6087,0.6667,0.3023,0.2439],

[0.4591,0.0000,0.9091,0.6522,0.6667,0.3023,0.2439],

[0.4651,0.0000,0.9091,0.6957,0.6667,0.3023,0.2439],

[0.5102,0.0000,0.9091,0.7391,0.6667,0.3023,0.2439],

[0.5067,0.0000,0.9091,0.7826,0.6667,0.3023,0.2439],

[0.4635,0.0000,0.9091,0.8261,0.6667,0.3023,0.2439],

[0.4224,0.0000,0.9091,0.8696,0.6667,0.3023,0.2439],

[0.3796,0.0000,0.9091,0.9130,0.6667,0.3023,0.2439],

[0.3292,0.0000,0.9091,0.9565,0.6667,0.3023,0.2439],

[0.2940,0.0000,0.9091,1.0000,0.6667,0.3023,0.2439]]),tensor([0.3675]))]

每一行對應(yīng)一個時刻點的負荷以及環(huán)境變量，此時input_size=7。

III.LSTM模型

這里采用了深入理解PyTorch中LSTM的輸入和輸出（從input輸入到Linear輸出）中的模型：

classLSTM(nn.Module):

def__init__(self,input_size,hidden_size,num_layers,output_size,batch_size):

super().__init__()

self.input_size=input_size

self.hidden_size=hidden_size

self.num_layers=num_layers

self.output_size=output_size

self.num_directions=1

self.batch_size=batch_size

self.lstm=nn.LSTM(self.input_size,self.hidden_size,self.num_layers,batch_first=True)

self.linear=nn.Linear(self.hidden_size,self.output_size)

defforward(self,input_seq):

h_0=torch.randn(self.num_directions*self.num_layers,self.batch_size,self.hidden_size).to(device)

c_0=torch.randn(self.num_directions*self.num_layers,self.batch_size,self.hidden_size).to(device)

#print(input_seq.size())

seq_len=input_seq.shape[1]

#input(batch_size,seq_len,input_size)

input_seq=input_seq.view(self.batch_size,seq_len,self.input_size)

#output(batch_size,seq_len,num_directions*hidden_size)

output,_=self.lstm(input_seq,(h_0,c_0))

#print('output.size=',output.size())

#print(self.batch_size*seq_len,self.hidden_size)

output=output.contiguous().view(self.batch_size*seq_len,self.hidden_size)#(5*30,64)

pred=self.linear(output)#pred()

#print('pred=',pred.shape)

pred=pred.view(self.batch_size,seq_len,-1)

pred=pred[:,-1,:]

returnpred

IV.訓練

defLSTM_train(name,b):

Dtr,Dte=nn_seq(file_name=name,B=b)

input_size,hidden_size,num_layers,output_size=7,64,1,1

model=LSTM(input_size,hidden_size,num_layers,output_size,batch_size=b).to(device)

loss_function=nn.MSELoss().to(device)

optimizer=torch.optim.Adam(model.parameters(),lr=0.05)

#訓練

epochs=30

foriinrange(epochs):

cnt=0

print('當前',i)

for(seq,label)inDtr:

cnt+=1

seq=seq.to(device)

label=label.to(device)

y_pred=model(seq)

loss=loss_function(y_pred,label)

optimizer.zero_grad()

loss.backward()

optimizer.step()

ifcnt%100==0:

print('epoch',i,':',cnt-100,'~',cnt,loss.item())

state={'model':model.state_dict(),'optimizer':optimizer.state_dict()}

torch.save(state,LSTM_PATH)

V.測試

deftest(name,b):

globalMAX,MIN

Dtr,Dte=nn_seq(file_name=name,B=b)

pred=[]

y=[]

print('loadingmodel...')

input_size,hidden_size,num_layers,output_size=7,64,1,1

model=LSTM(input_size,hidden_size,num_layers,output_size,batch_size=b).to(device)

model.load_state_dict(torch.load(LSTM_PATH)['model'])

model.eval()

print('predicting...')

for(seq,target)inDte:

target=list(chain.from_iterable(target.data.tolist()))

y.extend(target)

seq=seq.to(device)

withtorch.no_grad():

y_pred=model(seq)

y_pred=list(chain.from_iterable(y_pred.data.tolist()))

pred.extend(y_pred)

y,pred=np.array([y]),np.array