0
0

长短时记忆网络(Long Short Term Memory，LSTM)详解

长短时记忆网络是循环神经网络(RNNs)的一种，用于时序数据的预测或文本翻译等方面。LSTM的出现主要是用来解决传统RNN长期依赖问题。对于传统的RNN，随着序列间隔的拉长，由于梯度爆炸或梯度消失等问题，使得模型在训练过程中不稳定或根本无法进行有效学习。与RNN相比，LSTM的每个单元结构——LSTM cell增加了更多的结构，通过设计门限结构解决长期依赖问题，所以LSTM可以具有比较长的短期记忆，与RNN相比具有更好的效果。

一：基本原理

关于LSTM，其整体结构与RNN基本完全相同，都是由多个cell串联起来，并且也有双向LSTM、深层LSTM，结构与RNN也完全相同。所以兔兔在这里不在赘述，需要了解的同学可以参考兔兔的上一篇循环神经网络(Recurrent Neural Network)详解。兔兔在下面着重讲述LSTM cell结构。

上图为一个LSTM cell的整体结构，与RNN相比，我们发现在cell直间除了之前的隐藏状态ht,还多了一个Ct，并且内部结构也相对较为复杂。对于LSTM cell，内部分为三个部分：遗忘门(也称为保持门 keep gate)、输入门(也称为更新门update gate，写入门write gate)与输出门。

（1）遗忘门(Forget Gate)

在LSTM cell中，保持门用于控制记忆单元里那些信息舍弃(遗忘)或保留。设输入数据xt特征数量为p，则dim=(p,1)，h(t-1)的维度为dim=(q,1)，参数矩阵W_{if}的维度为dim=(q,p)，偏置b_{if}：dim=(q,1)，W_{hf}：dim=(q,q),偏置b_{hf}：dim=(q,1)。最终的输出ft为：

f_t=sigmoid(W_{if}.x_t+b_{if}+W_{hf}.h_{t-1}+b_{hf})

（2）输入门(Input Gate)

输入门决定更新记忆单元的信息，包括Sigmoid与Tanh两个部分，它们两个都包含当前时刻的输入xt与上一时刻隐藏状态h(t-1)。Sigmoid部分的参数有W_{ii}、b_{ii}、W_{hi}、b_{hi}，dim分别为(q,p),(q,1),(q,q),(q,1)；Tanh部分的参数W_{ig}、b_{ig}、W_{hg}、b_{hg}，dim分别为(q,p),(q,1),(q,q),(q,1)。

得到输入门的两个输出it、gt后，再由遗忘门得到的ft与上一时刻的状态C(t-1)进行计算，可以得到更新的状态Ct。

i_t=sigmoid(W_{ii}.x_t+b_{ii}+W_{hi}.h_{t-1}+b_{hi}) \\g_t=tanh(W_{ig}.x_t+b_{ig}+W_{hg}.h_{t-1}+b_{hg})\\c_t=f_t*c_{t-1}+i*g_t

这里的乘法"*"是两个向量对应位置相乘，准确来说是哈达玛乘积，一般也可以用\odot表示。而且这里ft、c(t-1)、it、gt、ct的维度都为(q,1)。

（3）输出门(Output Gate)

输出门的功能是读取刚刚更新过的神经网络状态，对记忆单元进行输出，而具体哪些信息可以输出受输出门的控制。

输出层的参数有W_{io}、h_{io}、W_{ho}、b_{ho}。通过输出门得到ot，最终由ot与ct得到此时刻的输出ht，并且也可以继续传递到下一个cell。

o_t=sigmoid(W_{io}.x_t+b_{io}+W_{ho}.h_{t-1}+b_{ho}) \\ h_t=o_t*tanh(c_t)

LSTM与RNN同样权值共享，每一个LSTM cell都使用相同的参数。在这个模型中，所需要的参数有W_{if},W_{ii},W_{ig},W_{io},W_{hf},W_{hi},W_{hg},W_{ho}与b_{if},b_{ii},b_{ig},b_{io},b_{hf},b_{hi},b_{hg},b_{ho}，有时根据需要也可以不需要偏置b。

二：方法实现

1.使用Pytorch设计LSTMCell与LSTM

  1. import torch
  2. from torch import nn
  3. from torch.utils.data import DataLoader
  4. import numpy as np
  5. class LSTMCell(nn.Module):
  6.     def __init__(self,input_size,hidden_size):
  7.         '''
  8.         :param input_size: 输入特征个数
  9.         :param hidden_size: 隐藏层c、h的特征数
  10.         '''
  11.         super().__init__()
  12.         self.w_if=nn.Parameter(torch.randn(size=(input_size,hidden_size)))
  13.         self.w_ii=nn.Parameter(torch.randn(size=(input_size,hidden_size)))
  14.         self.w_ig=nn.Parameter(torch.randn(size=(input_size,hidden_size)))
  15.         self.w_io=nn.Parameter(torch.randn(size=(input_size,hidden_size)))
  16.         self.w_hf=nn.Parameter(torch.randn(size=(hidden_size,hidden_size)))
  17.         self.w_hi=nn.Parameter(torch.randn(size=(hidden_size,hidden_size)))
  18.         self.w_hg=nn.Parameter(torch.randn(size=(hidden_size,hidden_size)))
  19.         self.w_ho=nn.Parameter(torch.randn(size=(hidden_size,hidden_size)))
  20.         self.b_if=nn.Parameter(torch.randn(size=(1,hidden_size)))
  21.         self.b_ii=nn.Parameter(torch.randn(size=(1,hidden_size)))
  22.         self.b_ig=nn.Parameter(torch.randn(size=(1,hidden_size)))
  23.         self.b_io=nn.Parameter(torch.randn(size=(1,hidden_size)))
  24.         self.b_hf=nn.Parameter(torch.randn(size=(1,hidden_size)))
  25.         self.b_hi=nn.Parameter(torch.randn(size=(1,hidden_size)))
  26.         self.b_hg=nn.Parameter(torch.randn(size=(1,hidden_size)))
  27.         self.b_ho=nn.Parameter(torch.randn(size=(1,hidden_size)))
  28.         self.sigmoid=nn.Sigmoid()
  29.         self.tanh=nn.Tanh()
  30.     def forward(self,input,h,c):
  31.         ft=self.sigmoid(torch.matmul(input,self.w_if)+self.b_if+torch.matmul(h,self.w_hf)+self.b_hf)
  32.         it=self.sigmoid(torch.matmul(input,self.w_ii)+self.b_ii+torch.matmul(h,self.w_hi)+self.b_hi)
  33.         gt=self.tanh(torch.matmul(input,self.w_ig)+self.b_ig+torch.matmul(h,self.w_hg)+self.b_hg)
  34.         ct=torch.mul(ft,c)+torch.mul(it,gt)
  35.         ot=self.sigmoid(torch.matmul(input,self.w_io)+self.b_io+torch.matmul(h,self.w_ho)+self.b_ho)
  36.         ht=torch.mul(ot,self.tanh(ct))
  37.         return ht,ct
  38. class LSTM(LSTMCell):
  39.     def __init__(self,input_size,hidden_size):
  40.         super().__init__(input_size,hidden_size)
  41.         self.input_size=input_size
  42.         self.hidden_size=hidden_size
  43.         self.lstmcell=LSTMCell(input_size,hidden_size)
  44.     def forward(self,input):
  45.         b,l,h=input.shape
  46.         output=[]
  47.         h0=torch.zeros(size=(1,self.hidden_size))
  48.         c0=torch.zeros(size=(1,self.hidden_size))
  49.         for i in range(l):
  50.             ht,ct=self.lstmcell(input[:,i,:],h0,c0)
  51.             output.append(ht)
  52.             h0,c0=ht,ct
  53.         return torch.stack(output).permute(1,0,2),c0
  55. a=np.arange(0,100,0.1)
  56. b=np.sin(a)
  57. data=[]
  58. label=[]
  59. for i in range(1000-20):
  60.     data.append(b[i:i+10].reshape(-1,1))
  61.     label.append(b[i+10:i+20].reshape(-1,1))
  63. class dataset:
  64.     def __init__(self):
  65.         self.data=torch.tensor(np.array(data),dtype=torch.float32)
  66.         self.label=torch.tensor(np.array(label),dtype=torch.float32)
  67.         self.n=len(data)
  68.     def __len__(self):
  69.         return self.n
  70.     def __getitem__(self, item):
  71.         return self.data[item],self.label[item]
  73. if __name__=='__main__':
  74.     lstm=LSTM(input_size=1,hidden_size=1)
  75.     optim=torch.optim.Adam(params=lstm.parameters())
  76.     Loss=nn.MSELoss()
  77.     data=DataLoader(dataset(),shuffle=True,batch_size=4)
  78.     for i in range(10):
  79.         for d in data:
  80.             yp=lstm(d[0])[0]
  81.             loss=Loss(yp,d[1])
  82.             optim.zero_grad()
  83.             loss.backward()
  84.             optim.step()
  85.             print(loss)

2.使用Pytorch中LSTM方法

Pytorch中LSTMCell与LSTM方法中参数与RNN方法中的参数完全一致，意义相同，并且也可以控制参数来设置双向LSTM、深层LSTM等模型，兔兔在这里不再赘述，需要的同学可以参考兔兔前面的文章。唯一不同的是，LSTMcell除了input 和h，还需要c。LSTM的输出除了所有LSTM cell的输出，还有最后一个cell的ct、ht的输出。

兔兔在这里仍以Bitcoin数据为例，利用三个月的数据进行训练，从而能够进行未来数据的预测。这部分代码与之前RNN那里的代码几乎相同，只是把nn.RNN改成了nn.LSTM。

  1. import pandas as pd
  2. import numpy as np
  3. import re
  4. import torch
  5. from torch import nn
  6. from torch.utils.data import DataLoader
  8. df=pd.DataFrame(pd.read_csv('Bitcoin.csv'))
  9. n=len(df)
  10. opening=[]
  11. closing=[]
  12. transaction=[]
  13. for i in range(n):
  14.       a = re.split(',',df['开盘'].loc[i])
  15.       a=float(a[0])*1000+float(a[1])
  16.       b = re.split(',', df['收盘'].loc[i])
  17.       b = float(b[0]) * 1000 + float(b[1])
  18.       c=re.split('K',df['交易量'].loc[i])[0]
  19.       c=float(c)
  20.       opening.append(a)
  21.       closing.append(b)
  22.       transaction.append(c)
  23. data=np.array([opening,closing,transaction]).transpose()
  25. seq_size=10 #RNN长度
  26. train_num=1000#训练数据个数
  27. epoch=100
  29. train_data=[]
  30. train_label=[]
  31. for i in range(1000):
  32.       j=np.random.randint(0,n-seq_size-2)
  33.       train_data.append(data[j:j+seq_size])
  34.       train_label.append(data[j+2:j+seq_size+2])
  36. train_data=np.float32(np.array(train_data,dtype=object))
  37. train_label=np.float32(np.array(train_label,dtype=object))
  38. class dataset:
  39.       def __init__(self):
  40.           self.data=torch.tensor(train_data,dtype=torch.float32)
  41.           self.label=torch.tensor(train_label,dtype=torch.float32)
  42.       def __len__(self):
  43.           return train_num
  44.       def __getitem__(self, item):
  45.            return self.data[item],self.label[item]
  47. lstm=nn.LSTM(input_size=3,hidden_size=3,bidirectional=False,batch_first=True,num_layers=2)
  48. optim=torch.optim.Adam(params=lstm.parameters(),lr=1e-12)
  49. Loss=nn.MSELoss()
  50. data=DataLoader(dataset(),batch_size=10)
  52. for i in range(epoch):
  53.       print('the {} epoch'.format(i))
  54.       for d in data:
  55.             yp=lstm(d[0])[0]
  56.             loss=Loss(yp,d[1])
  57.             optim.zero_grad()
  58.             loss.backward()
  59.             optim.step()
  60.             print(loss.data)

三：总结

长短时记忆网络作为RNN的一种改进方法，在一定程度上克服了长期依赖问题，并且成为目前循环神经网络在实际应用中的常用模型之一。当然，该模型在更为复杂的问题上仍有一定的不足，所以在RNNs中仍有其它种类的循环神经网络，用以解决不同的问题。

标签： lstm 深度学习 人工智能
本文转载自: https://blog.csdn.net/weixin_60737527/article/details/127129363
版权归原作者 生信小兔 所有， 如有侵权，请联系我们删除。
登录后发布评论

“长短时记忆网络(Long Short Term Memory，LSTM)详解”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？