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

I.前言

在上一篇文章深入理解PyTorch中LSTM的輸入和輸出（從input輸入到Linear輸出）中，我詳細地解釋了如何利用PyTorch來搭建一個LSTM模型，本篇文章的主要目的是搭建一個LSTM模型用于時間序列預(yù)測。

系列文章：

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

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

PyTorch深度學(xué)習(xí)LSTM從input輸入到Linear輸出

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

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

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

本篇文章暫時不考慮其它變量，只考慮用歷史負荷來預(yù)測未來負荷。

本文中，我們根據(jù)前24個時刻的負荷下一時刻的負荷。有關(guān)多變量預(yù)測請參考：PyTorch搭建LSTM實現(xiàn)多變量時間序列預(yù)測（負荷預(yù)測）。

defload_data(file_name):

globalMAX,MIN

df=pd.read_csv('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()

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

data=data.values.tolist()

seq=[]

foriinrange(len(data)-24):

train_seq=[]

train_label=[]

forjinrange(i,i+24):

train_seq.append(load[j])

train_label.append(load[i+24])

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

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為訓(xùn)練集，Dte為測試集。

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#單向LSTM

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)

seq_len=input_seq.shape[1]#(5,24)

#input(batch_size,seq_len,input_size)

input_seq=input_seq.view(self.batch_size,seq_len,1)#(5,24,1)

#output(batch_size,seq_len,num_directions*hidden_size)

output,_=self.lstm(input_seq,(h_0,c_0))#output(5,24,64)

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

pred=self.linear(output)#pred(150,1)

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

pred=pred[:,-1,:]#(5,1)

returnpred

IV.訓(xùn)練

defLSTM_train(name,b):

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

input_size,hidden_size,num_layers,output_size=1,64,5,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.001)

#訓(xùn)練

epochs=15

cnt=0

foriinrange(epochs):

cnt=0

print('當(dāng)前',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)

一共訓(xùn)練了15輪：

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=1,64,5,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)

seq_len=seq.shape[1]

seq=seq.view(model.batch_size,seq_len,1)#(5,24,1)

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(pred)

y=(MAX-MIN)*y+MIN

pred=(MAX-MIN)*pred+MIN

print('accuracy:',get_mape(y,pred))

#plot

x=[iforiinrange(1,151)]

x_smooth=np.linspace(np.min(x),np.max(x),600)

y_smooth=make_interp_spline(x,y[0:150])(x_smooth)

plt.plot(x_smooth,y_smooth,c='green',marker='*',ms=1,alpha=0.75,label='true')

y_smooth=make_interp_spline(x,pred[0:150])(x_smooth)

plt.plo