【python，机器学习，nlp】RNN循环神经网络

RNN(Recurrent Neural Network)，中文称作循环神经网络，它一般以序列数据为输入，通过网络内部的结构设计有效捕捉序列之间的关系特征，一般也是以序列形式进行输出。

因为RNN结构能够很好利用序列之间的关系，因此针对自然界具有连续性的输入序列，如人类的语言，语音等进行很好的处理，广泛应用于NLP领域的各项任务，如文本分类，情感分析，意图识别，机器翻译等．

RNN模型的分类：

这里我们将从两个角度对RNN模型进行分类．第一个角度是输入和输出的结构，第二个角度是RNN的内部构造．

按照输入和输出的结构进行分类：

N vs N-RNN

它是RNN最基础的结构形式，最大的特点就是：输入和输出序列是等长的．由于这个限制的存在，使其适用范围比较小，可用于生成等长度的合辙诗句．

N vs 1-RNN

有时候我们要处理的问题输入是一个序列，而要求输出是一个单独的值而不是序列，要在最后一个隐层输出h上进行线性变换。

大部分情况下，为了更好的明确结果，还要使用sigmoid或者softmax进行处理．这种结构经常被应用在文本分类问题上．

1 vs N-RNN

我们最常采用的一种方式就是使该输入作用于每次的输出之上．这种结构可用于将图片生成文字任务等．

N vs M-RNN

这是一种不限输入输出长度的RNN结构，它由编码器和解码器两部分组成，两者的内部结构都是某类RNN，它也被称为seq2seq架构。

输入数据首先通过编码器，最终输出一个隐含变量c，之后最常用的做法是使用这个隐含变量c作用在解码器进行解码的每一步上，以保证输入信息被有效利用。

按照RNN的内部构造进行分类：

传统RNN

内部计算函数

tanh的作用： 用于帮助调节流经网络的值，tanh函数将值压缩在﹣1和1之间。

传统RNN的优势：
由于内部结构简单，对计算资源要求低，相比之后我们要学习的RNN变体：LSTM和GRU模型参数总量少了很多，在短序列任务上性能和效果都表现优异。

传统rnn的缺点：
传统RNN在解决长序列之间的关联时，通过实践，证明经典RNN表现很差，原因是在进行反向传播的时候，过长的序列导致梯度的计算异常，发生梯度消失或爆炸。

LSTM

LSTM (Long Short-Term Memory）也称长短时记忆结构，它是传统RNN的变体，与经典RNN相比能够有效捕捉长序列之间的语义关联，缓解梯度消失或爆炸现象，同时LSTM的结构更复杂。

LSTM缺点：由于内部结构相对较复杂，因此训练效率在同等算力下较传统RNN低很多．

LSTM优势：LSTM的门结构能够有效减缓长序列问题中可能出现的梯度消失或爆炸，虽然并不能杜绝这种现象，但在更长的序列问题上表现优于传统RNN.

 

它的核心结构可以分为四个部分去解析：

遗忘门

与传统RNN的内部结构计算非常相似，首先将当前时间步输入x(t）与上一个时间步隐含状态h(t-1）拼接， 得到［x(t), h(t-1)]，然后通过一个全连接层做变换，最后通过sigmoid函数（变化到【0，1】）进行激活得到f(t)，我们可以将f(t）看作是门值，好比一扇门开合的大小程度，门值都将作用在通过该扇门的张量，遗忘门门值将作用的上一层的细胞状态上，代表遗忘过去的多少信息，又因为遗忘门门值是由x(t), h(t-1）计算得来的，因此整个公式意味着根据当前时间步输入和上一个时间步隐含状态h(t-1）来决定遗忘多少上一层的细胞状态所携带的过往信息．

输入门

输入门的计算公式有两个，第一个就是产生输入门门值的公式，它和遗忘门公式几乎相同，区别只是在于它们之后要作用的目标上，这个公式意味着输入信息有多少需要进行过滤．输入门的第二个公式是与传统RNN的内部结构计算相同．对于LSTM来讲，它得到的是当前的细胞状态，而不是像经典RNN一样得到的是隐含状态．

细胞状态

我们看到输入门的计算公式有两个，第一个就是产生输入门门值的公式，它和遗忘门公式几乎相同，区别只是在于它们之后要作用的目标上．这个公式意味着输入信息有多少需要进行过滤．输入门的第二个公式是与传统RNN的内部结构计算相同．对于LSTM来讲，它得到的是当前的细胞状态，而不是像经典RNN一样得到的是隐含状态。

输出门

输出门部分的公式也是两个，第一个即是计算输出门的门值，它和遗忘门，输入门计算方式相同．第二个即是使用这个门值产生隐含状态h(t)，他将作用在更新后的细胞状态C(t）上，并做tanh激活，最终得到h(t）作为下一时间步输入的一部分．整个输出门的程，就是为了产生隐含状态h(t)。

Bi-LSTM

Bi-LSTM即双向LSTM，它没有改变LSTM本身任何的内部结构，只是将LSTM应用两次且方向不同，再将两次得到的LSTM结果进行拼接作为最终输出

GRU

GRU(Gated Recurrent Unit）也称门控循环单元结构，它也是传统RNN的变体，同LSTM一样能够有效捕捉长序列之间的语义关联，缓解梯度消失或爆炸现象．同时它的结构和计算要比LSTM 更简单。

GRU的优势：GRU和LSTM作用相同，在捕捉长序列语义关联时，能有效抑制梯度消失或爆炸，效果都优于传统rnn且计算复杂度相比lstm要小．

GRU的缺点：GRU仍然不能完全解决梯度消失问题，同时其作用RNN的变体，有着RNN结构本身的一大弊端，即不可并行计算，这在数据量和模型体量逐步增大的未来，是RNN发展的关键瓶颈

它的核心结构可以分为两个部分去解析：

更新门 

重置门

Bi-GRU

Bi-GRU与Bi-LSTM的逻辑相同，都是不改变其内部结构，而是将模型应用两次且方向不同，再将两次得到的LSTM结果进行拼接作为最终输出．具体参见上小节中的Bi-LSTM。

注意力机制

注意力机制是注意力计算规则能够应用的深度学习网络的载体，同时包括一些必要的全连接层以及相关张量处理，使其与应用网络融为一体．使自注意力计算规则的注意力机制称为自注意力机制．

注意力计算规则

它需要三个指定的输入Q(query), K(key), V(value), 然后通过计算公式得到注意力的结果，这个结果代表query在key和value作用下的注意力表示．当输入的Q=K=V时，称作自注意力计算规则．

注意力机制的作用

在解码器端的注意力机制： 能够根据模型目标有效的聚焦编码器的输出结果，当其作为解码器的输入时提升效果，改善以往编码器输出是单一定长张量，无法存储过多信息的情况．

在编码器端的注意力机制：主要解决表征问题，相当于特征提取过程，得到输入的注意力表示．一般使用自注意力（self-attention).

注意力机制实现步骤

第一步：根据注意力计算规则，对Q,K,V进行相应的计算．

第二步：根据第一步采用的计算方法，如果是拼接方法，则需要将Q与第二步的计算结果再进行拼接，如果是转置点积，一般是自注意力，Q与V相同，则不需要进行与Q的拼接．

第三步：最后为了使整个attention机制按照指定尺寸输出，使用线性层作用在第二步的结果上做一个线性变换，得到最终对Q的注意力表示．

代码实现

传统模型

import torch
import torch.nn as nn

"""
nn.RNN类初始化主要参数解释
input_size：输入张量x中特征维度的大小
hidden_size：隐层张量h中特征维度的大小
num_layers: 隐含层的数量．
nonlinearity: 激活函数的选择，默认是tanh.
"""
rnn=nn.RNN(input_size=5,hidden_size=6,num_layers=1)

"""
设定输入的张量x
第一个参数：sequence_length（输入序列的长度）
第二个参数：batch_size（批次的样本数）
第三个参数：input_size（输入张量x的维度）
"""
input=torch.randn(1,3,5)
"""
设定初始化的h0
第一个参数：num_layers *num_directions（层数＊网络方向数）
第二个参数：batch_size（批次的样本数）
第三个参数：hiddeh_size（隐藏层的维度）
"""
h0=torch.randn(1,3,6)

"""
nn.RNN类实例化对象主要参数解释
input: 输入张量x
h0：初始化的隐层张量h
"""
output,hn=rnn(input,h0)

# 传统RNN
class RNN(nn.Module):
    def __init__(self,input_size,hidden_size,output_size,num_layers=1):
        """
        input_size:代表输入张量x中最后一个维度
        hidden_size: 代表隐藏层张量的最后一个维度
        output_size: 代表线性层最后的输出维度
        num_layers:代表RNN网络的层数
        """
        
        super(RNN,self).__init__()
        self.input_size=input_size
        self.hidden_size=hidden_size
        self.output_size=output_size
        self.num_layers=num_layers
        self.rnn=nn.RNN(input_size,hidden_size,num_layers)
        
        # 全连接线性层
        self.linear=nn.linear(hidden_size,output_size)
        # 预定义的softmax层
        self.softmax=nn.LogSoftmax(dim=-1)
        
    def forward(self,input1,hidden):
        input1=input1.unsqueeze(0)
        rr,hn=self.rnn(input1,hidden)
        return self.softmax(self.linear(rr)),hn
    
    def init_hidden(self):
        """初始化全零的隐藏层张量"""
        return torch.zeros(self.num_layers,1,self.hidden_size)

 

LSTM模型

import torch
import torch.nn as nn

"""
nn.LSTM类初始化主要参数解释：
input_size: 输入张量x中特征维度的大小．
hidden_size: 隐层张量h中特征维度的大小．
num_layers: 隐含层的数量．
bidirectional: 是否选择使用双向LSTM，如果为True，则使用；默认不使用．
"""
rnn=nn.LSTM(input_size=5,hidden_size=6,num_layers=2)

"""
设定输入的张量x
第一个参数：sequence_length（输入序列的长度）
第二个参数：batch_size（批次的样本数）
第三个参数：input_size（输入张量x的维度）
"""
input=torch.randn(1,3,5)
"""
设定初始化的h0,c0
第一个参数：num_layers *num_directions（层数＊网络方向数）
第二个参数：batch_size（批次的样本数）
第三个参数：hiddeh_size（隐藏层的维度）
"""
h0=torch.randn(2,3,6)
c0=torch.randn(2,3,6)

"""
nn.LSTM类实例化对象主要参数解释
input: 输入张量x
h0:初始化的隐层张量h.
cO:初始化的细胞状态张量c.
"""
output,(hn,cn)=rnn(input,(h0,c0))

# LSTM型RNN
class LSTM(nn.Module):
    def __init__(self,input_size,hidden_size,output_size,num_layers=1):
        """
        input_size:代表输入张量x中最后一个维度
        hidden_size: 代表隐藏层张量的最后一个维度
        output_size: 代表线性层最后的输出维度
        num_layers:代表RNN网络的层数
        """
        super(LSTM,self).__init__()
        self.input_size=input_size
        self.hidden_size=hidden_size
        self.output_size=output_size
        self.num_layers=num_layers
        self.lstm=nn.LSTM(input_size,hidden_size,num_layers)
        # 全连接线性层
        self.linear=nn.linear(hidden_size,output_size)
        # 预定义的softmax层
        self.softmax=nn.LogSoftmax(dim=-1)
        
    def forward(self,input1,hidden,c):
        input1=input1.unsqueeze(0)
        rr,(hn,cn)=self.lstm(input1,(hidden,c))
        return self.softmax(self.linear(hn)),hn,cn
    
    def init_hidden_and_c(self):
        c=hidden=torch=torch.zeros(self.num_layers,1,self.hidden_size)
        return hidden,c

 

GRU模型

import torch
import torch.nn as nn

"""
nn.GRU类初始化主要参数解释
Input_size: 输入张量x中特征维度的大小
hidden_size:隐层张量h中特征维度的大小
num_layers:隐含层的数量
bidirectional: 是否选择使用双向LSTM，如果为True，则使用；默认不使用
"""
rnn=nn.GRU(input_size=5,hidden_size=6,num_layers=2)

"""
设定输入的张量x
第一个参数：sequence_length（输入序列的长度）
第二个参数：batch_size（批次的样本数）
第三个参数：input_size（输入张量x的维度）
"""
input=torch.randn(1,3,5)
"""
设定初始化的h0
第一个参数：num_layers *num_directions（层数＊网络方向数）
第二个参数：batch_size（批次的样本数）
第三个参数：hiddeh_size（隐藏层的维度）
"""
h0=torch.randn(2,3,6)

"""
nn.GRU类实例化对象主要参数解释
input: 输入张量x.
h0:初始化的隐层张量h.
"""
output,hn=rnn(input,h0)

# GRU模型
class GRU(nn.Module):
    def __init__(self,input_size,hidden_size,output_size,num_layers=1):
        """
        input_size:代表输入张量x中最后一个维度
        hidden_size: 代表隐藏层张量的最后一个维度
        output_size: 代表线性层最后的输出维度
        num_layers:代表RNN网络的层数
        """
        super(GRU,self).__init__()
        self.input_size=input_size
        self.hidden_size=hidden_size
        self.output_size=output_size
        self.num_layers=num_layers
        self.gru=nn.GRU(input_size,hidden_size,num_layers)
        self.linear=nn.linear(hidden_size,output_size)
        self.softmax=nn.LogSoftmax(dim=-1)
        
    def forward(self,input1,hidden):
        input1=input1.unsqueeze(0)
        output,hn=self.gru(input1,hidden)
        return self.softmax(self.linear(hidden)),hn
    
    def init_hidden(self):
        return torch.zeros(self.num_layers,1,self.hidden_size)

 

注意力模型

import torch
import torch.nn as nn
import torch.nn.functional as F

#建立attn类
class Attn(nn.Module):
    def __init__(self, query_size,key_size,value_size1,value_size2,output_size):
        """_summary_

        Args:
            query_size (_type_): 代表的是Q的最后一个维度
            key_size (_type_): 代表的K的最后一个维度
            value_size1 (_type_): 代表value的导数第二维大小
            value_size2 (_type_): 代表value的倒数第一维大小
            output_size (_type_): 代表输出的最后一个维度的大小
        """
        super(Attn, self).__init__()
        self.query_size = query_size
        self.key_size = key_size
        self.value_size1 = value_size1
        self.value_size2 = value_size2
        self.output_size = output_size
        
        # 初始化注意力机制
        self.attn=nn.Linear(self.query_size+self.key_size,self.value_size1)
        self.attn_combine=nn.Linear(self.query_size+self.value_size2,self.output_size)
        
    def forward(self,query,key,value):
        """_summary_

        Args:
            query (_type_): 代表Q
            key (_type_): 代表K
            value (_type_): 代表V

        Returns:
            _type_: 返回注意力机制的输出
        """
        # 计算注意力权重
        attn_weights=F.softmax(self.attn(torch.cat((query[0],key[0]),1)),dim=1)
        attn_applied=torch.bmm(attn_weights.unsqueeze(0),value)
        
        # 计算注意力机制的输出
        output=torch.cat((query[0],attn_applied[0]),1)
        
        output=self.attn_combine(output).unsqueeze(0)
        
        return output,attn_weights

query_size=32
key_size=32
value_size1=32
value_size2=64
output_size=64

#初始化attn
attn=Attn(query_size,key_size,value_size1,value_size2,output_size)
#使用attn实例
Q=torch.randn(1,1,32)
K=torch.randn(1,1,32)
V=torch.randn(1,32,64)
output=attn(Q,K,V)