原文鏈接
這個問題是國際航空乘客預測問題， 數據是1949年1月到1960年12月國際航空公司每個月的乘客數量（單位：千人），共有12年144個月的數據。
鏈接：https://pan.baidu.com/s/1JJTe2CL0BxpmyewKCsvc0w 提取碼：6666
數據趨勢：
訓練程序：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch
from torch import nn
from torch.autograd import Variable
#LSTM（Long Short-Term Memory）是長短期記憶網絡
data_csv = pd.read_csv('C:/Users/DZF/Desktop/LSTM/data.csv',usecols=[1])
#pandas.read_csv可以讀取CSV（逗號分割）文件、文本類型的文件text、log類型到DataFrame
#原有兩列，時間和乘客數量，usecols=1：只取了乘客數量一列
plt.plot(data_csv)
plt.show()
#數據預處理
data_csv = data_csv.dropna() #去掉na數據
dataset = data_csv.values #字典(Dictionary) values()：返回字典中的所有值。
dataset = dataset.astype('float32') #astype(type):實現變量類型轉換
max_value = np.max(dataset)
min_value = np.min(dataset)
scalar = max_value-min_value
dataset = list(map(lambda x: x/scalar, dataset)) #將數據標准化到0~1之間
#lambda:定義一個匿名函數，區別於def
#map(f(x),Itera):map()接收函數f和一個list,把函數f依次作用在list的每個元素上,得到一個新的object並返回
'''
接著我們進行數據集的創建，我們想通過前面幾個月的流量來預測當月的流量，
比如我們希望通過前兩個月的流量來預測當月的流量，我們可以將前兩個月的流量
當做輸入，當月的流量當做輸出。同時我們需要將我們的數據集分為訓練集和測試
集，通過測試集的效果來測試模型的性能，這裡我們簡單的將前面幾年的數據作為
訓練集，後面兩年的數據作為測試集。
'''
def create_dataset(dataset,look_back=2):#look_back 以前的時間步數用作輸入變量來預測下一個時間段
dataX, dataY=[], []
for i in range(len(dataset) - look_back):
a = dataset[i:(i+look_back)] #i和i+1賦值
dataX.append(a)
dataY.append(dataset[i+look_back]) #i+2賦值
return np.array(dataX), np.array(dataY) #np.array構建數組
data_X, data_Y = create_dataset(dataset)
#data_X: 2*142 data_Y: 1*142
#劃分訓練集和測試集，70%作為訓練集
train_size = int(len(data_X) * 0.7)
test_size = len(data_X)-train_size
train_X = data_X[:train_size]
train_Y = data_Y[:train_size]
test_X = data_X[train_size:]
test_Y = data_Y[train_size:]
train_X = train_X.reshape(-1,1,2) #reshape中，-1使元素變為一行，然後輸出為1列，每列2個子元素
train_Y = train_Y.reshape(-1,1,1) #輸出為1列，每列1個子元素
test_X = test_X.reshape(-1,1,2)
train_x = torch.from_numpy(train_X) #torch.from_numpy(): numpy中的ndarray轉化成pytorch中的tensor(張量)
train_y = torch.from_numpy(train_Y)
test_x = torch.from_numpy(test_X)
#定義模型 輸入維度input_size是2，因為使用2個月的流量作為輸入，隱藏層維度hidden_size可任意指定，這裡為4
class lstm_reg(nn.Module):
def __init__(self,input_size,hidden_size, output_size=1,num_layers=2):
super(lstm_reg,self).__init__()
#super() 函數是用於調用父類(超類)的一個方法，直接用類名調用父類
self.rnn = nn.LSTM(input_size,hidden_size,num_layers) #LSTM 網絡
self.reg = nn.Linear(hidden_size,output_size) #Linear 函數繼承於nn.Module
def forward(self,x): #定義model類的forward函數
x, _ = self.rnn(x)
s,b,h = x.shape #矩陣從外到裡的維數
#view()函數的功能和reshape類似，用來轉換size大小
x = x.view(s*b, h) #輸出變為（s*b）*h的二維
x = self.reg(x)
x = x.view(s,b,-1) #卷積的輸出從外到裡的維數為s,b,一列
return x
net = lstm_reg(2,4) #input_size=2，hidden_size=4
criterion = nn.MSELoss() #損失函數均方差
optimizer = torch.optim.Adam(net.parameters(),lr=1e-2)
#構造一個優化器對象 Optimizer,用來保存當前的狀態，並能夠根據計算得到的梯度來更新參數
#Adam 算法:params (iterable)：可用於迭代優化的參數或者定義參數組的 dicts lr:學習率
for e in range(10000):
var_x = Variable(train_x) #轉為Variable（變量）
var_y = Variable(train_y)
out = net(var_x)
loss = criterion(out, var_y)
optimizer.zero_grad() #把梯度置零，也就是把loss關於weight的導數變成0.
loss.backward() #計算得到loss後就要回傳損失，這是在訓練的時候才會有的操作，測試時候只有forward過程
optimizer.step() #回傳損失過程中會計算梯度，然後optimizer.step()根據這些梯度更新參數
if (e+1)%100 == 0:
print('Epoch: {}, Loss:{:.5f}'.format(e+1, loss.data[0]))
torch.save(net.state_dict(), 'net_params.pkl') #保存訓練文件net_params.pkl
#state_dict 是一個簡單的python的字典對象,將每一層與它的對應參數建立映射關系
測試程序：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch
from torch import nn
from torch.autograd import Variable
data_csv = pd.read_csv('C:/Users/DZF/Desktop/LSTM/data.csv',usecols=[1])
# plt.plot(data_csv)
# plt.show()
#數據預處理
data_csv = data_csv.dropna() #去掉na數據
dataset = data_csv.values #字典(Dictionary) values()：返回字典中的所有值。
dataset = dataset.astype('float32') # astype(type):實現變量類型轉換
max_value = np.max(dataset)
min_value = np.min(dataset)
scalar = max_value-min_value
dataset = list(map(lambda x: x/scalar, dataset)) #將數據標准化到0~1之間
def create_dataset(dataset,look_back=2):
dataX, dataY=[], []
for i in range(len(dataset)-look_back):
a=dataset[i:(i+look_back)]
dataX.append(a)
dataY.append(dataset[i+look_back])
return np.array(dataX), np.array(dataY)
data_X, data_Y = create_dataset(dataset)
class lstm_reg(nn.Module):
def __init__(self,input_size,hidden_size, output_size=1,num_layers=2):
super(lstm_reg,self).__init__()
self.rnn = nn.LSTM(input_size,hidden_size,num_layers)
self.reg = nn.Linear(hidden_size,output_size)
def forward(self,x):
x, _ = self.rnn(x)
s,b,h = x.shape
x = x.view(s*b, h)
x = self.reg(x)
x = x.view(s,b,-1)
return x
net = lstm_reg(2,4)
net.load_state_dict(torch.load('net_params.pkl'))
data_X = data_X.reshape(-1, 1, 2) #reshape中，-1使元素變為一行，然後輸出為1列，每列2個子元素
data_X = torch.from_numpy(data_X) #torch.from_numpy(): numpy中的ndarray轉化成pytorch中的tensor（張量）
var_data = Variable(data_X) #轉為Variable（變量）
pred_test = net(var_data) #產生預測結果
pred_test = pred_test.view(-1).data.numpy() #view(-1)輸出為一行
plt.plot(pred_test, 'r', label='prediction')
plt.plot(dataset, 'b', label='real')
plt.legend(loc='best') #loc顯示圖像 'best'表示自適應方式
plt.show()
預測結果：
學習更多編程知識，請關注我的公眾號：
代碼的路
本文由 mdnice 多平台發布
