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
文章来源:https://www.toymoban.com/news/detail-802324.html
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)
文章来源地址https://www.toymoban.com/news/detail-802324.html
注意力模型
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)
到了这里,关于【python,机器学习,nlp】RNN循环神经网络的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!