神经网络 时间序列 python,lstm神经网络算法

　　原始链接

　　这个问题是国际航空旅客的预测。数据是从1949年1月到1960年12月，共12年144个月，每个月国际航空公司的旅客人数(以千计)。

　　趋势：

　　培训计划：

　　将numpy作为np导入

　　进口熊猫作为pd

　　将matplotlib.pyplot作为plt导入

　　进口火炬

　　从火炬进口nn

　　来自torch.autograd导入变量

　　#LSTM(长短期记忆)是一个长短期记忆网络。

　　data _ CSV=PD . read _ CSV( C:/Users/my/Desktop/LSTM/data . CSV ，usecols=[1])

　　#pandas.read_CSV可以将CSV(逗号分隔)文件、文本类型文件和日志类型文件读取到DataFrame。

　　#原来的两列，时间和乘客人数，usecols=1:只选择乘客人数。

　　plt.plot(数据csv)

　　plt.show()

　　#数据预处理

　　Data_csv=data_csv.dropna() #删除na数据

　　dataset=data _ CSV . values # Dictionary(Dictionary)values():返回字典中的所有值。

　　dataset=dataset . astype( float 32 )# astype(type):实现变量类型转换

　　max_value=np.max(数据集)

　　最小值=np.min(数据集)

　　标量=最大值-最小值

　　dataset=list(map(lambda x:x/scalar，dataset)) #将数据标准化为0~1

　　#lambda:定义一个匿名函数，不同于def

　　#map(f(x)，Itera):map()接收函数f和一个链表，将函数f依次作用于链表的每个元素，得到一个新的对象并返回。

　　然后我们创建数据集，我们想通过前几个月的流量来预测当月的流量。

　　比如我们希望通过前两个月的流量来预测当月的流量，我们可以对比前两个月的流量

　　作为输入，当前月的流量作为输出。同时，我们需要将数据集划分为训练集和测试集。

　　设置，通过测试设置的效果来测试模型的性能。这里，我们简单地用往年的数据作为

　　训练集，以未来两年的数据作为测试集。

　　DEF _ dataset (dataset，look _ back=2): # look _ back前面的时间步长作为输入变量，预测下一个时间段。

　　dataX，dataY=[]，[]

　　对于范围内的I(len(dataset)-look _ back):

　　A=dataset[i:(i回看)] #i和i 1赋值

　　dataX.append(a)

　　datay . append(dataset[ilook _ back])# I2赋值

　　返回np.array (datax)，np.array (datay) # np.array构建数组

　　data_X，data_Y=create_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

　　训练X=数据X[:训练大小]

　　火车_Y=数据_Y[:火车_大小]

　　test_X=data_X[train_size:]

　　test_Y=data_Y[train_size:]

　　train _ x=train _ x . shape(-1，1，2)# shape，-1将元素变为一行，然后输出为1列，每列有2个子元素。

　　train _ y=train _ y . shape(-1，1，1) #输出为1列，每列有1个子元素。

　　test _ X=test _ X . shape(-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。

　　lstm_reg类(nn。模块):

　　def __init__(self，input_size，hidden_size，output_size=1，num_layers=2):

　　超级(lstm_reg，self)。__init__()

　　#super()函数是用来调用父类(超类)的方法，直接用类名调用父类。

　　Self.rnn=nn.lstm (input _ size，hidden _ size，num _ layers) # lstm网络

　　Self.reg=nn.linear (hidden _ size，output _ size) #线性函数继承自nn。组件

　　Def forward(self，x): #定义模型类的forward函数

　　x，_=self.rnn(x)

　　s，B，H=X .形状#矩阵从外向内的尺寸

　　#view()函数类似于shape，用于转换大小。

　　X=x.view(s*b，h) #输出变成(s * b) * h的二维。

　　x=自我注册(x)

　　X=x.view(s，b，-1) #卷积输出由外向内的维数为s，b，一列。

　　返回x

　　net=lstm_reg(2，4) #input_size=2，hidden_size=4

　　判据=nn。ms loss()#损失函数的均方误差

　　optimizer=torch . optim . Adam(net . parameters()，lr=1e-2)

　　#构造优化器对象优化器以保存当前状态并根据计算的梯度更新参数。

　　#亚当算法：params (iterable):可用于迭代优化的参数或者定义参数组的词典：学习率

　　对于范围内的e(10000):

　　var_x=变量(火车x) #转为变量（变量)

　　var_y=变量(火车_y)

　　out=net(var_x)

　　损失=标准(out，var_y)

　　optimizer.zero_grad() #把梯度置零，也就是把失败关于重量的导数变成0.

　　loss.backward() #计算得到失败后就要回传损失，这是在训练的时候才会有的操作，测试时候只有向前过程

　　optimizer.step() #回传损失过程中会计算梯度，然后optimizer.step()根据这些梯度更新参数

　　如果(1)0==0:

　　打印(纪元：{}，损失：{:5f} .格式(e 1，loss.data[0])

　　torch.save(net.state_dict()， net_params.pkl) #保存训练文件网络_参数。韩国品牌

　　#状态_字典是一个简单的大蟒的字典对象，将每一层与它的对应参数建立映射关系

　　测试程序：

　　将数组作为铭牌导入

　　进口熊猫作为螺纹中径

　　将matplotlib.pyplot作为血小板计数导入

　　进口火炬

　　从火炬进口神经网络

　　来自火炬，亲笔签名导入变量

　　data _ CSV=PD。read _ CSV( C:/Users/my/Desktop/LSTM/data。CSV ，usecols=[1])

　　# plt.plot(data_csv)

　　# plt.show()

　　#数据预处理

　　data_csv=data_csv.dropna() #去掉钠数据

　　dataset=data_csv.values #字典（字典)值():返回字典中的所有值。

　　数据集=数据集。astype( float 32 )# astype(type):实现变量类型转换

　　max_value=np.max(数据集)

　　最小值=np.min(数据集)

　　标量=最大值-最小值

　　数据集=列表(映射(x:x/标量，数据集))#将数据标准化到0~1之间

　　def create_dataset(dataset，look_back=2):

　　dataX，dataY=[]，[]

　　对于范围内的I(len(dataset)-look _ back):

　　a=数据集[我：(我回头看)]

　　dataX.append(a)

　　数据追加(数据集[我回头看])

　　返回数组(数据)

　　数据X，数据Y=创建数据集(数据集)

　　lstm_reg类(nn .模块):

　　def __init__(self，input_size，hidden_size，output_size=1，num_layers=2):

　　超级(lstm_reg，self).__init__()

　　self.rnn=nn .LSTM(输入尺寸，隐藏尺寸，层数)

　　self.reg=nn .线性（隐藏大小，输出大小)

　　向前定义（自身，x):

　　x，_=self.rnn(x)

　　形状，形状，形状

　　x=x.view(s*b，h)

　　x=自我注册(十)

　　x=x.view(s，b，-1)

　　返回x

　　net=lstm_reg(2，4)

　　网。load _ state _ dict(火炬。load( net _ params。pkl ))

　　data _ X=data _ X . shape(-1，1，2)# shape中，-1使元素变为一行，然后输出为一列，每列2个子元素

　　data _ X=火炬。from _ numpy(data _ X)# torch。from _ numpy():numpy中的多维数组转化成框架中的张量（张量)

　　var_data=变量(data_X) #转为变量（变量)

　　pred_test=net(var_data) #产生预测结果

　　预测测试=预测测试。视图(-1)。数据。numpy()#视图(-1)输出为一行

　　plt.plot(预测测试， r ，标签=预测)

　　plt.plot(数据集， b ，标签=实数)

　　plt.legend(loc=best) #loc显示图像最佳表示自适应方式

　　plt.show()

　　预测结果：

　　学习更多编程知识，请关注我的公众号：

　　代码的路

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。