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

import torch
from torch import nn
from torch.utils.data import DataLoader
import numpy as np
class LSTMCell(nn.Module):
    def __init__(self,input_size,hidden_size):
        '''
        :param input_size: 输入特征个数
        :param hidden_size: 隐藏层c、h的特征数
        '''
        super().__init__()
        self.w_if=nn.Parameter(torch.randn(size=(input_size,hidden_size)))
        self.w_ii=nn.Parameter(torch.randn(size=(input_size,hidden_size)))
        self.w_ig=nn.Parameter(torch.randn(size=(input_size,hidden_size)))
        self.w_io=nn.Parameter(torch.randn(size=(input_size,hidden_size)))
        self.w_hf=nn.Parameter(torch.randn(size=(hidden_size,hidden_size)))
        self.w_hi=nn.Parameter(torch.randn(size=(hidden_size,hidden_size)))
        self.w_hg=nn.Parameter(torch.randn(size=(hidden_size,hidden_size)))
        self.w_ho=nn.Parameter(torch.randn(size=(hidden_size,hidden_size)))
        self.b_if=nn.Parameter(torch.randn(size=(1,hidden_size)))
        self.b_ii=nn.Parameter(torch.randn(size=(1,hidden_size)))
        self.b_ig=nn.Parameter(torch.randn(size=(1,hidden_size)))
        self.b_io=nn.Parameter(torch.randn(size=(1,hidden_size)))
        self.b_hf=nn.Parameter(torch.randn(size=(1,hidden_size)))
        self.b_hi=nn.Parameter(torch.randn(size=(1,hidden_size)))
        self.b_hg=nn.Parameter(torch.randn(size=(1,hidden_size)))
        self.b_ho=nn.Parameter(torch.randn(size=(1,hidden_size)))
        self.sigmoid=nn.Sigmoid()
        self.tanh=nn.Tanh()
    def forward(self,input,h,c):
        ft=self.sigmoid(torch.matmul(input,self.w_if)+self.b_if+torch.matmul(h,self.w_hf)+self.b_hf)
        it=self.sigmoid(torch.matmul(input,self.w_ii)+self.b_ii+torch.matmul(h,self.w_hi)+self.b_hi)
        gt=self.tanh(torch.matmul(input,self.w_ig)+self.b_ig+torch.matmul(h,self.w_hg)+self.b_hg)
        ct=torch.mul(ft,c)+torch.mul(it,gt)
        ot=self.sigmoid(torch.matmul(input,self.w_io)+self.b_io+torch.matmul(h,self.w_ho)+self.b_ho)
        ht=torch.mul(ot,self.tanh(ct))
        return ht,ct
class LSTM(LSTMCell):
    def __init__(self,input_size,hidden_size):
        super().__init__(input_size,hidden_size)
        self.input_size=input_size
        self.hidden_size=hidden_size
        self.lstmcell=LSTMCell(input_size,hidden_size)
    def forward(self,input):
        b,l,h=input.shape
        output=[]
        h0=torch.zeros(size=(1,self.hidden_size))
        c0=torch.zeros(size=(1,self.hidden_size))
        for i in range(l):
            ht,ct=self.lstmcell(input[:,i,:],h0,c0)
            output.append(ht)
            h0,c0=ht,ct
        return torch.stack(output).permute(1,0,2),c0

a=np.arange(0,100,0.1)
b=np.sin(a)
data=[]
label=[]
for i in range(1000-20):
    data.append(b[i:i+10].reshape(-1,1))
    label.append(b[i+10:i+20].reshape(-1,1))

class dataset:
    def __init__(self):
        self.data=torch.tensor(np.array(data),dtype=torch.float32)
        self.label=torch.tensor(np.array(label),dtype=torch.float32)
        self.n=len(data)
    def __len__(self):
        return self.n
    def __getitem__(self, item):
        return self.data[item],self.label[item]

if __name__=='__main__':
    lstm=LSTM(input_size=1,hidden_size=1)
    optim=torch.optim.Adam(params=lstm.parameters())
    Loss=nn.MSELoss()
    data=DataLoader(dataset(),shuffle=True,batch_size=4)
    for i in range(10):
        for d in data:
            yp=lstm(d[0])[0]
            loss=Loss(yp,d[1])
            optim.zero_grad()
            loss.backward()
            optim.step()
            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。

import pandas as pd
import numpy as np
import re
import torch
from torch import nn
from torch.utils.data import DataLoader

df=pd.DataFrame(pd.read_csv('Bitcoin.csv'))
n=len(df)
opening=[]
closing=[]
transaction=[]
for i in range(n):
      a = re.split(',',df['开盘'].loc[i])
      a=float(a[0])*1000+float(a[1])
      b = re.split(',', df['收盘'].loc[i])
      b = float(b[0]) * 1000 + float(b[1])
      c=re.split('K',df['交易量'].loc[i])[0]
      c=float(c)
      opening.append(a)
      closing.append(b)
      transaction.append(c)
data=np.array([opening,closing,transaction]).transpose()

seq_size=10 #RNN长度
train_num=1000#训练数据个数
epoch=100

train_data=[]
train_label=[]
for i in range(1000):
      j=np.random.randint(0,n-seq_size-2)
      train_data.append(data[j:j+seq_size])
      train_label.append(data[j+2:j+seq_size+2])

train_data=np.float32(np.array(train_data,dtype=object))
train_label=np.float32(np.array(train_label,dtype=object))
class dataset:
      def __init__(self):
          self.data=torch.tensor(train_data,dtype=torch.float32)
          self.label=torch.tensor(train_label,dtype=torch.float32)
      def __len__(self):
          return train_num
      def __getitem__(self, item):
           return self.data[item],self.label[item]

lstm=nn.LSTM(input_size=3,hidden_size=3,bidirectional=False,batch_first=True,num_layers=2)
optim=torch.optim.Adam(params=lstm.parameters(),lr=1e-12)
Loss=nn.MSELoss()
data=DataLoader(dataset(),batch_size=10)

for i in range(epoch):
      print('the {} epoch'.format(i))
      for d in data:
            yp=lstm(d[0])[0]
            loss=Loss(yp,d[1])
            optim.zero_grad()
            loss.backward()
            optim.step()
            print(loss.data)

三:总结

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


本文转载自: https://blog.csdn.net/weixin_60737527/article/details/127129363
版权归原作者 生信小兔 所有, 如有侵权,请联系我们删除。

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

还没有评论