精华内容
下载资源
问答
  • 注意LSTM 使用TensorFlow对LSTM实施注意力模型
  • 基于注意力的BiLSTM-CRF模型在中国临床命名实体识别中的应用
  • 情绪分析 总览 情感分析是一种自然语言处理(NLP)任务,其目的是评估文本块的极性/情感。... 情绪分析中常见的子任务是: 消息极性分类:给定一条消息,对消息的整体上下文极性进行分类是正面,负面还是中性。...
  • 本文通过训练双向长短期记忆网络BiLSTM注意力机制相结合的多层文本分类模型,将其应用到招聘信息分类中.该模型包括One-hot词向量输入层、BiLSTM层、注意力机制层和输出层.其中One-hot层构建招聘词典,节省了大量...
  • 该算法首先从每个视频中提取20帧图像,通过Inceptionv3模型提取图像中的深层特征,然后构建向前和向后的Bi-LSTM神经网络学习特征向量中的时序信息,接着利用注意力机制自适应地感知对识别结果有较大影响的网络权重,使...
  • 针对时序数据特征,提出一种基于注意力机制的卷积神经网络(CNN)联合长短期记忆网络(LSTM)的神经网络预测模型,融合粗细粒度特征实现准确的时间序列预测。该模型由两部分构成:基于注意力机制的CNN,在标准CNN...
  • 目录注意力机制实现方法代码注意力层 注意力机制实现方法 现在已经有很多篇文章对注意力机制进行了介绍,简单来说,注意力机制通过引入一层激活函数...但是目前看见的注意力模型都是只对时间步应用注意力机制,或者只对

    注意力机制实现方法

    现在已经有很多篇文章对注意力机制进行了介绍,简单来说,注意力机制可以通过下面操作实现:
    引入一层激活函数为softmax的全连接层,输出一组权重来代表注意力,之后将原始输入与权重进行组合。很多博客在keras实现上借鉴了github的这个项目
    我在用keras搭建的LSTM网络训练一个物理模型时,输入数据是多个时间步的多个物理量,感觉可以用注意力机制对不同时间步和物理量提前分配权重,让结果更好反映出物理本质。但是目前看见的注意力模型都是只对时间步应用注意力机制,或者只对维度应用注意力机制,所以我稍微改进下常见的注意力层,对时间步和维度都应用了注意力机制。

    测试数据

    博文【深度学习】 基于Keras的Attention机制代码实现及剖析——LSTM+Attention中,作者对注意力机制进行了详细的实验。参考文中的方法,先写一个生成数据的函数。

    def get_data_recurrent(n, time_steps, input_dim, attention_column=10,attention_index=4):
        x = np.random.standard_normal(size=(n, time_steps, input_dim))  # 标准正态分布随机特征值
        y = np.random.randint(low=0, high=2, size=(n, 1))  # 二分类,随机标签值
        # print(x[:,1,1].shape)
        # print(y[:].shape)
        x[:, attention_column, attention_index] = np.reshape(y[:],len(y))  
        return x, y
    

    上述程序中n为生成的大小,input_dim为维度,timestep为时间步数,本次取输入为n= 30000, input_dim = 9 ,timesteps = 20。其中第timestep=11,input_dim=9时,x的值与y相同。

    注意力层构造

    博文【深度学习】 基于Keras的Attention机制代码实现及剖析——LSTM+Attention中只对时间步应用注意力机制的层如下

    def attention_3d_block(inputs):
        # inputs.shape = (batch_size, time_steps, input_dim)
        input_dim = int(inputs.shape[2])
        a = Permute((2, 1))(inputs)
        a = Reshape((input_dim, TIME_STEPS))(a) # this line is not useful. It's just to know which dimension is what.
        a = Dense(TIME_STEPS, activation='softmax')(a)
        if SINGLE_ATTENTION_VECTOR:
            a = Lambda(lambda x: K.mean(x, axis=1), name='dim_reduction')(a)
            a = RepeatVector(input_dim)(a)
        a_probs = Permute((2, 1), name='attention_vec')(a)
        output_attention_mul = Multiply()([inputs, a_probs])
        return output_attention_mul
    

    若要在维度和时间步同时分配注意力,本次选择采用以下步骤:

    1、先对原始输入,通过两个全连接层,分别计算对时间步和维度的注意力分配矩阵A、B,对本次的原始输入,注意力分配矩阵为:

    A=[a1a1...a1a2a2...a2......a20a20...a20]20×9,n=120an=1 A=\begin{gathered} \begin{bmatrix} a_1 & a_1 & ... & a_1 \\ a_2 & a_2 & ... & a_2\\.&&&.\\.&&&.\\ .&&&.\\a_{20} & a_{20} & ... & a_{20} \end{bmatrix} \end{gathered}_{20\times9},\sum_{n=1}^{20}a_n=1

    B=[b1b2...b9b1b2...b9..b1b2...b9]20×9,n=19bn=1, B=\begin{gathered} \begin{bmatrix} b_1 & b_2 & ... & b_9 \\ b_1 & b_2 & ... & b_9\\.\\.\\ b_1 & b_2 & ... & b_9 \end{bmatrix} \end{gathered}_{20\times9},\sum_{n=1}^{9}b_n=1,

    最后的注意力权重为A、B的逐元素积
    [a1×b1a1×b2...a1×b9a2×b1a2×b2...a2×b9..a20×b1a20×b2...a20×b9]20×9 \begin{gathered} \begin{bmatrix} a_1\times b_1 & a1\times b_2 & ... &a_1\times b_9 \\ a_2\times b_1 &a_2\times b_2 & ... &a_2\times b_9\\.\\.\\a_{20}\times b_1 &a_{20}\times b_2 & ... &a_{20}\times b_9 \end{bmatrix} \end{gathered}_{20\times9}
    上述矩阵与原始输入逐元素积得到注意力层的输出。
    注意力层的子程序为:

    def attention_3d_block_method2(inputs):
        # inputs.shape = (batch_size, time_steps, input_dim)
        input_dim = int(inputs.shape[2])
        a1 = Permute((2, 1))(inputs)
        # a1 = Reshape((input_dim, TIME_STEPS))(a1)  # this line is not useful. It's just to know which dimension is what.
        a1 = Dense(TIME_STEPS, activation='softmax')(a1)
        a1 = Lambda(lambda x: K.mean(x, axis=1))(a1)
        a1 = RepeatVector(input_dim)(a1)
        a1 = Permute((2,1),name='attention_vec1')(a1)
        a2 = Dense(input_dim, activation='softmax',name='attention_vec2')(inputs)
        a2 = Lambda(lambda x: K.mean(x, axis=1))(a2)
        a2 = RepeatVector(TIME_STEPS)(a2)
        a_probs = Multiply()([a1,a2])
        output_attention_mul = Multiply()([inputs, a_probs])
        return output_attention_mul
    

    完整的模型程序为:

    def model_attention_applied_before_lstm():
        K.clear_session()  # 清除之前的模型,省得压满内存
        inputs = Input(shape=(TIME_STEPS, INPUT_DIM,))
        attention_mul = attention_3d_block_method2(inputs)
        # attention_mul = attention_3d_block(inputs)
        lstm_units = 32
        attention_mul = LSTM(lstm_units, return_sequences=False)(attention_mul)
        output = Dense(1, activation='sigmoid')(attention_mul)
        model = Model(input=[inputs], output=output)
        return model
    

    结果

    时间步注意力分配

    维度注意力分配

    结果表明这种注意力层可以对维度和时间步分别分配注意力权重。

    展开全文
  • 循环神经网络(RNN),长短期记忆(LSTM),这些红得发紫的神经网络——是时候抛弃它们了! LSTM和RNN被发明于上世纪80、90年代,于2014年死而复生。接下来的几年里,它们成为了解决序列学习、序列转换(seq2seq)的...

    循环神经网络(RNN),长短期记忆(LSTM),这些红得发紫的神经网络——是时候抛弃它们了!

    LSTM和RNN被发明于上世纪80、90年代,于2014年死而复生。接下来的几年里,它们成为了解决序列学习、序列转换(seq2seq)的方式,这也使得语音到文本识别和Siri、Cortana、Google语音助理、Alexa的能力得到惊人的提升。

    另外,不要忘了机器翻译,包括将文档翻译成不同的语言,或者是神经网络机器翻译还可以将图像翻译为文本,文字到图像和字幕视频等等。

    在接下来的几年里,ResNet出现了。ResNet是残差网络,意为训练更深的模型。2016年,微软亚洲研究院的一组研究员在ImageNet图像识别挑战赛中凭借惊人的152层深层残差网络(deep residual networks),以绝对优势获得图像分类、图像定位以及图像检测全部三个主要项目的冠军。之后,Attention(注意力)模型出现了。

    虽然仅仅过去两年,但今天我们可以肯定地说:

    “不要再用RNN和LSTM了,它们已经不行了!”

    让我们用事实说话。Google、Facebook、Salesforce等企业越来越多地使用了基于注意力模型(Attention)的网络。

    所有这些企业已经将RNN及其变种替换为基于注意力的模型,而这仅仅是个开始。比起基于注意力的模型,RNN需要更多的资源来训练和运行。RNN命不久矣。

    为什么

    记住RNN和LSTM及其衍生主要是随着时间推移进行顺序处理。请参阅下图中的水平箭头:

    cb77e62ab101e8f1f1e9096f7a3436f035c2b73b

    RNN中的顺序处理

    水平箭头的意思是长期信息需在进入当前处理单元前顺序遍历所有单元。这意味着其能轻易被乘以很多次<0的小数而损坏。这是导致vanishing gradients(梯度消失)问题的原因。

    为此,今天被视为救星的LSTM模型出现了,有点像ResNet模型,可以绕过单元从而记住更长的时间步骤。因此,LSTM可以消除一些梯度消失的问题。

    c7315718cce452582f600fe690cfc68cc3f4a138

    LSTM中的顺序处理

    从上图可以看出,这并没有解决全部问题。我们仍然有一条从过去单元到当前单元的顺序路径。事实上,这条路现在更复杂了,因为它有附加物,并且忽略了隶属于它上面的分支。

    毫无疑问LSTM和GRU(Gated Recurrent Uni,是LSTM的衍生)及其衍生能够记住大量更长期的信息!但是它们只能记住100个量级的序列,而不是1000个量级,或者更长的序列。

    还有一个RNN的问题是,训练它们对硬件的要求非常高。另外,在我们不需要训练这些网络快速的情况下,它仍需要大量资源。同样在云中运行这些模型也需要很多资源。

    考虑到语音到文本的需求正在迅速增长,云是不可扩展的。我们需要在边缘处进行处理,比如Amazon Echo上处理数据。

    该做什么?

    如果要避免顺序处理,那么我们可以找到“前进”或更好“回溯”单元,因为大部分时间我们处理实时因果数据,我们“回顾过去”并想知道其对未来决定的影响(“影响未来”)。在翻译句子或分析录制的视频时并非如此,例如,我们拥有完整的数据,并有足够的处理时间。这样的回溯/前进单元是神经网络注意力(Neural Attention)模型组。

    为此,通过结合多个神经网络注意力模型,“分层神经网络注意力编码器”出现了,如下图所示:

    18628ae71dac418dbe8a80cfa3e277acc20e12b2

    分层神经网络注意力编码器

    “回顾过去”的更好方式是使用注意力模型将过去编码向量汇总到语境矢量 CT中。

    请注意上面有一个注意力模型层次结构,它和神经网络层次结构非常相似。这也类似于下面的备注3中的时间卷积网络(TCN)。

    在分层神经网络注意力编码器中,多个注意力分层可以查看最近过去的一小部分,比如说100个向量,而上面的层可以查看这100个注意力模块,有效地整合100 x 100个向量的信息。这将分层神经网络注意力编码器的能力扩展到10,000个过去的向量。

    这才是“回顾过去”并能够“影响未来”的正确方式!

    但更重要的是查看表示向量传播到网络输出所需的路径长度:在分层网络中,它与log(N)成正比,其中N是层次结构层数。这与RNN需要做的T步骤形成对比,其中T是要记住的序列的最大长度,并且T >> N。

    跳过3-4步追溯信息比跳过100步要简单多了!

    这种体系结构跟神经网络图灵机很相似,但可以让神经网络通过注意力决定从内存中读出什么。这意味着一个实际的神经网络将决定哪些过去的向量对未来决策有重要性。

    但是存储到内存怎么样呢?上述体系结构将所有先前的表示存储在内存中,这与神经网络图灵机(NTM)不同。这可能是相当低效的:考虑将每帧的表示存储在视频中——大多数情况下,表示向量不会改变帧到帧,所以我们确实存储了太多相同的内容!

    我们可以做的是添加另一个单元来防止相关数据被存储。例如,不存储与以前存储的向量太相似的向量。但这确实只是一种破解的方法,最好的方法是让应用程序指导哪些向量应该保存或不保存。这是当前研究的重点

    看到如此多的公司仍然使用RNN/LSTM进行语音到文本的转换,我真的十分惊讶。许多人不知道这些网络是如此低效和不可扩展。

    训练RNN和LSTM的噩梦

    RNN和LSTM的训练是困难的,因为它们需要存储带宽绑定计算,这是硬件设计者最糟糕的噩梦,最终限制了神经网络解决方案的适用性。简而言之,LSTM需要每个单元4个线性层(MLP层)在每个序列时间步骤中运行。

    线性层需要大量的存储带宽来计算,事实上,它们不能使用许多计算单元,通常是因为系统没有足够的存储带宽来满足计算单元。而且很容易添加更多的计算单元,但是很难增加更多的存储带宽(注意芯片上有足够的线,从处理器到存储的长电线等)。

    因此,RNN/LSTM及其变种不是硬件加速的良好匹配,我们在这里之前和这里都讨论过这个问题。一个解决方案将在存储设备中计算出来,就像我们在FWDNXT上工作的一样。

    总而言之,抛弃RNN吧。注意力模型真的就是你需要的一切!


    原文发布时间为:2018-05-2

    本文作者:文摘菌

    本文来自云栖社区合作伙伴“大数据文摘”,了解相关信息可以关注“大数据文摘”。

    展开全文
  • 睿智的seq2seq模型3——注意力机制概念详解与其在LSTM中的使用学习前言什么是注意力机制注意力机制的Keras实现1、生成数据集2、建立注意力模型3、建立整体神经网络代码&效果1、实现代码2、实现效果 学习前言 ...

    学习前言

    注意力机制很重要噢,要好好学习。
    在这里插入图片描述

    什么是注意力机制

    利用神经网络找到输入进来的特征,哪一部分更有用。

    假设我们要翻译一句话:
    打电脑游戏。
    也就是play computer game。
    在这里插入图片描述
    如果不引入注意力机制,那么我们从Encoder获得语义编码c之后,这个语义编码在Decoder中传递,其内容就和Encoder无关了。

    但是事实上我们希望在翻译打电脑游戏中的的时候,我们更注意打->play的转换,此时我们希望Decoder更加注意Encoder从中提取出来的特征。

    这就是注意力机制的概念,它的本意是让神经网络模型在做特定的事的时候可以注意到它需要注意的地方。

    由于神经网络是一堆数字的传递,每个事物的特征也是由一堆数字组成的,比如字的特征也是一堆数字,电脑的特征也是一堆数字,游戏的特征也是一堆数字,语义编码c就是这么多特征的组合。

    那么如何使得神经网络模型对某个内容进行注意呢?其实就是将改变不同内容的权重,当我们需要神经网络注意到的时候,我们只需要提高字的特征的权重就可以了。

    假设函数 f 可以用于提取特征,函数 g 可以实现解码。那么如果我们要神经网络注意到,可以通过如下方式进行。
    Cplay=g(0.8f(),0.1f(),0.1f()) C_{play} = g(0.8*f(打),0.1*f(电脑),0.1*f(游戏))

    注意力机制的Keras实现

    我将用一个小例子给大家演示一下Keras中的注意力机制的实现以及其作用。

    假设我们存在一个TIME_STEP为10,INPUT_DIM为2的输入。

    当我们的TIME_STEP为2的输入为[0,0]时,其输出为0;
    当我们的TIME_STEP为2的输入为[1,1]时,其输出为1;

    其它TIME_STEP等于其它的时候,如0,1,3,……9时,其对应的时间的输入为为符合正态分布的数。
    具体如下所示:

    #-------------------------------------#
    x = [[[14.05795148 10.6586937 ]
    	  [-5.17788409  3.0967234 ]
    	  [ 1.          1.        ]
    	  [-7.16327903  7.36591461]
    	  [ 3.07887461 18.46302035]
    	  [ 8.7123103  15.77254757]
    	  [-7.6266161  -4.56511326]
    	  [ 1.64038985  0.10782463]
    	  [ 3.62548177  3.22431191]
    	  [ 0.76630364 -3.95249622]]]
    y = [[1]]
    #-------------------------------------#
    #-------------------------------------#
    x = [[[ -4.22167643   1.98029051]
    	  [ -1.00985459  15.08588672]
    	  [  0.           0.        ]
    	  [ 13.48448467  -0.66743308]
    	  [ 31.3199347    3.0311851 ]
    	  [ -4.81579489   1.62016606]
    	  [  7.40993759   4.25739609]
    	  [ 13.37376609 -11.63055067]
    	  [ -6.46277603 -13.94173142]
    	  [-12.01871193  -9.53632924]]]
    y = [[0]]
    #-------------------------------------#
    

    因此,输出y只与TIME_STEP为2时的输入有关,如果我们为x添加了注意力机制来预测y,注意力机制应该非常注意TIME_STEP为2时的输入,也就是,该部分的权重会非常高。

    1、生成数据集

    我们可以通过如下方式生成数据集:

    import numpy as np
    
    def get_data_recurrent(n, time_steps, input_dim, attention_column=2):
        x = np.random.normal(loc=0, scale=10, size=(n, time_steps, input_dim))
        y = np.random.randint(low=0, high=2, size=(n, 1))
        x[:, attention_column, :] = np.tile(y[:], (1, input_dim))
        return x, y
    
    x, y = get_data_recurrent(1, 10, 2)
    print("x =",x)
    print("y =",y)
    

    2、建立注意力模型

    注意力机制在神经网络中的实现方式如下:
    在这里插入图片描述
    我们将一串时间序列传入到LSTM中,可以获得一个维度为(batch_size, time_steps, lstm_units)的输出,我们可以把其当作每一个时间节点的特征,我们把这样的一个输出作为上述图片的Input。

    经过Permute将2、1轴翻转后,其维度从(batch_size, time_steps, lstm_units)转化成(batch_size, lstm_units, time_steps)

    再经过一个全连接层和Softmax后,其维度仍为(batch_size, lstm_units, time_steps),其实际内涵为,利用全连接层计算每一个time_steps的权重。

    再经过Permute将2、1轴翻转后,其维度从(batch_size, lstm_units, time_steps)转化成(batch_size, time_steps, lstm_units)。代表每一个STEP中每一个特征的权重。

    最后将这个结果与Input相乘,也就是将每个STEP的权重,乘上他们的特征。
    实现代码如下:

    #-------------------------------------------#
    #   注意力模块
    #-------------------------------------------#
    def attention_3d_block(inputs):
        # inputs.shape = (batch_size, time_steps, lstm_units)
    
        # (batch_size, time_steps, lstm_units) -> (batch_size, lstm_units, time_steps)
        a = Permute((2, 1))(inputs)
    
        # 对最后一维进行全连接
        # (batch_size, lstm_units, time_steps) -> (batch_size, lstm_units, time_steps)
        a = Dense(TIME_STEPS, activation='softmax')(a)
    
        # (batch_size, lstm_units, time_steps) -> (batch_size, time_steps, lstm_units)
        a_probs = Permute((2, 1), name='attention_vec')(a)
    
        # 相乘
        # 相当于获得每一个step中,每个维度在所有step中的权重
        output_attention_mul = merge([inputs, a_probs], name='attention_mul', mode='mul')
        return output_attention_mul
    

    3、建立整体神经网络

    在上一步中,我们已经获得了具有权重的特征组合
    平铺和全连接后,就可以获得预测结果。
    实现代码如下:

    #-------------------------------------------#
    #  建立注意力模型
    #-------------------------------------------#
    def get_attention_model():
        inputs = Input(shape=(TIME_STEPS, INPUT_DIM,))
        lstm_units = 32
        # (batch_size, time_steps, INPUT_DIM) -> (batch_size, input_dim, lstm_units)
        lstm_out = LSTM(lstm_units, return_sequences=True)(inputs)
        attention_mul = attention_3d_block(lstm_out)
        # (batch_size, input_dim, lstm_units) -> (batch_size, input_dim*lstm_units)
        attention_mul = Flatten()(attention_mul)
        output = Dense(1, activation='sigmoid')(attention_mul)
        model = Model(input=[inputs], output=output)
        return model
    

    代码&效果

    1、实现代码

    from keras.layers import merge
    from keras.layers.core import *
    from keras.layers.recurrent import LSTM
    from keras.models import *
    import matplotlib.pyplot as plt
    import pandas as pd
    import numpy as np
    
    
    INPUT_DIM = 2
    TIME_STEPS = 10
    
    #-------------------------------------------#
    #   对每一个step的INPUT_DIM的attention几率
    #   求平均
    #-------------------------------------------#
    def get_activations(model, inputs, layer_name=None):
        inp = model.input
        for layer in model.layers:
            if layer.name == layer_name:
                Y = layer.output
        model = Model(inp,Y)
        out = model.predict(inputs)
        out = np.mean(out[0],axis=-1)
        return out
    #-------------------------------------------#
    #   获得数据集
    #   attention_column代表我们希望被注意的列
    #-------------------------------------------#
    def get_data_recurrent(n, time_steps, input_dim, attention_column=2):
        x = np.random.normal(loc=0, scale=10, size=(n, time_steps, input_dim))
        y = np.random.randint(low=0, high=2, size=(n, 1))
        x[:, attention_column, :] = np.tile(y[:], (1, input_dim))
        return x, y
    #-------------------------------------------#
    #   注意力模块
    #-------------------------------------------#
    def attention_3d_block(inputs):
        # inputs.shape = (batch_size, time_steps, lstm_units)
    
        # (batch_size, time_steps, lstm_units) -> (batch_size, lstm_units, time_steps)
        a = Permute((2, 1))(inputs)
    
        # 对最后一维进行全连接
        # (batch_size, lstm_units, time_steps) -> (batch_size, lstm_units, time_steps)
        a = Dense(TIME_STEPS, activation='softmax')(a)
    
        # (batch_size, lstm_units, time_steps) -> (batch_size, time_steps, lstm_units)
        a_probs = Permute((2, 1), name='attention_vec')(a)
    
        # 相乘
        # 相当于获得每一个step中,每个维度在所有step中的权重
        output_attention_mul = merge([inputs, a_probs], name='attention_mul', mode='mul')
        return output_attention_mul
    
    #-------------------------------------------#
    #  建立注意力模型
    #-------------------------------------------#
    def get_attention_model():
        inputs = Input(shape=(TIME_STEPS, INPUT_DIM,))
        lstm_units = 32
        # (batch_size, time_steps, INPUT_DIM) -> (batch_size, input_dim, lstm_units)
        lstm_out = LSTM(lstm_units, return_sequences=True)(inputs)
        attention_mul = attention_3d_block(lstm_out)
        # (batch_size, input_dim, lstm_units) -> (batch_size, input_dim*lstm_units)
        attention_mul = Flatten()(attention_mul)
        output = Dense(1, activation='sigmoid')(attention_mul)
        model = Model(input=[inputs], output=output)
        return model
    
    if __name__ == '__main__':
    
        N = 100000
    
        X, Y = get_data_recurrent(N, TIME_STEPS, INPUT_DIM)
    
        model = get_attention_model()
    
        model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
        print(model.summary())
    
        model.fit(X, Y, epochs=1, batch_size=64, validation_split=0.1)
    
        attention_vectors = []
        for i in range(300):
            testing_X, testing_Y = get_data_recurrent(1, TIME_STEPS, INPUT_DIM)
            attention_vector = get_activations(model,testing_X,layer_name='attention_vec')
            print('attention =', attention_vector)
            assert (np.sum(attention_vector) - 1.0) < 1e-5
            attention_vectors.append(attention_vector)
    
        attention_vector_final = np.mean(np.array(attention_vectors), axis=0)
    
        pd.DataFrame(attention_vector_final, columns=['attention (%)']).plot(kind='bar',
                                                                             title='Attention Mechanism as '
                                                                                   'a function of input'
                                                                                   ' dimensions.')
        plt.show()
    

    2、实现效果

    在这里插入图片描述
    我们可以发现,第二个SETP的特征的权重最大。

    展开全文
  • 添加一些注意力 首先,我们需要了解什么是注意力。 为了在时间步长t生成一个单词,我们需要对输入序列中的每个单词给予多少关注?这就是注意力机制概念背后的关键直觉。 让我们用一个简单的例子来理解这一点: ...

    摘要是自然语言处理领域中最具挑战性和最有趣的问题之一。它是一个从多种文本资源(如书籍、新闻文章、博客文章、研究论文、电子邮件和tweet)中生成简洁而有意义的文本摘要的过程。现在,随着大量的文本文档的可用性,摘要是一个更加重要的任务。

    那么有哪些不同的方法呢?

    萃取总结

    这些方法依赖于从一段文本中提取几个部分,比如短语和句子,然后将它们堆在一起创建摘要。因此,在提取方法中,识别出用于总结的正确句子是至关重要的。让我们通过一个例子来理解这一点。

    Text: Messi and Ronaldo have better records than their counterparts. Performed exceptionally across all competitions. They are considered as the best in our generation.*

    Abstractive summary: Messi and Ronaldo have better records than their counterparts. Best in our generation.

    正如你在上面看到的,这些粗体的单词被提取出来并加入到一个摘要中——尽管有时这些摘要在语法上可能很奇怪。

    摘要式的总结

    这些方法使用先进的NLP技术产生一个全新的总结。本摘要的某些部分甚至可能不会出现在原文中。让我们通过一个例子来理解这一点。

    Text: Messi and Ronaldo have better records than their counterparts. Performed exceptionally across all competitions. They are considered as the best in our generation.

    Abstractive summary: Messi and Ronaldo have better records than their counterparts, so they are considered as the best in our generation.

    摘要文本摘要算法创建新的短语和句子,从原始文本中传递最有用的信息——就像人类一样。

    在本文中,我们将重点研究抽象摘要技术,并将利用编解码器架构来解决这一问题。

    什么是编码器-解码器架构?

    常用的序列-序列模型(编码器-解码器)的整体结构如下图所示


    该模型由编码器、中间矢量和解码器三部分组成。

    编码器

    该编码器基本上由一系列LSTM/GRU单元组成(请查看LSTM/GRU文档以更好地理解架构)。
    编码器接受输入序列并将信息封装为内部状态向量。
    解码器使用编码器的输出和内部状态。
    在我们的文本摘要问题中,输入序列是文本中需要汇总的所有单词的集合。每个单词都表示为x_i,其中i是单词的顺序。

    中间(编码器)向量

    这是模型的编码器部分产生的最终隐藏状态。用上面的公式计算。
    这个向量旨在封装所有输入元素的信息,以帮助解码器做出准确的预测。
    它作为模型的解码器部分的初始隐藏状态。

    译码器

    一种由几个循环单元组成的堆栈,其中每个单元在一个时间步长t预测输出y_t。
    每个循环单元从前一个单元接受一个隐藏状态,并产生和输出它自己的隐藏状态。
    在摘要问题中,输出序列是来自摘要文本的所有单词的集合。每个单词都表示为y_i,其中i是单词的顺序。
    任意隐藏状态h_i的计算公式为:


    正如你所看到的,我们只是用前一个隐藏状态来计算下一个。

    t时刻的输出y_t用公式计算:

    我们使用当前时间步长的隐藏状态和各自的权值W(S)来计算输出。Softmax用于创建一个概率向量,它将帮助我们确定最终的输出(例如回答问题中的单词)。

    添加一些注意力

    首先,我们需要了解什么是注意力。

    为了在时间步长t生成一个单词,我们需要对输入序列中的每个单词给予多少关注?这就是注意力机制概念背后的关键直觉。

    让我们用一个简单的例子来理解这一点:

    Question: In the last decade, *who* is the best *Footballer*?

    Answer: *Lionel Messi* is the best *player*.

    在上面的例子中,问题中的第五个单词和梅西有关,第九个单词足球运动员和第六个单词球员有关。

    因此,我们可以增加源序列中产生目标序列的特定部分的重要性,而不是查看源序列中的所有单词。这是注意力机制背后的基本思想。

    根据被关注上下文向量的推导方式,有两种不同的注意机制:

    Global Attention

    在这里,注意力被放在所有的源位置上。换句话说,为了得到参与的上下文向量,我们考虑了编码器的所有隐藏状态。在这个总结任务中,我们将使用Global Attention。

    Local Attention

    在这里,注意力只放在几个源位置上。在推导参与上下文向量时,只考虑编码器的少数隐藏状态。

    现在让我们了解这种注意力是如何真正起作用的:

    编码器输出源序列中每个时间步长j的隐藏状态(hj)
    同样,解码器输出目标序列中每一个时间步长i的隐藏状态(si)
    我们计算一个称为对齐分数(eij)的分数,在这个分数的基础上,使用一个评分函数将源单词与目标单词对齐。利用score函数从源隐藏状态hj和目标隐藏状态si计算对齐得分。由:

    其中eij为目标时间步长i和源时间步长j的对齐得分。

    我们使用softmax函数对对齐分数进行归一化,以检索注意力权重(aij):

    计算编码器hj的注意权值aij与隐藏状态的乘积的线性和,得到上下文向量Ci:


    将所述解码器在时间步长i时的参与上下文向量与目标隐藏状态连接,生成参与隐藏向量Si,其中Si= concatenate([Si;Ci)
    然后将参与的隐藏向量Si送入稠密层产生yi, yi=dense(Si)。

    让我们通过一个示例来理解上面的注意机制步骤。假设源文本序列为[x1, x2, x3, x4],目标摘要序列为[y1, y2]。

    编码器读取整个源序列并输出每个时间步长的隐藏状态,例如h1, h2, h3, h4


    解码器读取由一个时间步长偏移的整个目标序列,并输出每个时间步长(例如s1、s2、s3)的隐藏状态

    目标timestep i = 1

    利用score函数从源隐藏状态hi和目标隐藏状态s1计算对齐得分e1j:

    e11= score(s1, h1)
    e12= score(s1, h2)
    e13= score(s1, h3)
    e14= score(s1, h4)
    

    使用softmax对对齐分数e1j进行归一化,得到注意力权重a1j:

    a11= exp(e11)/((exp(e11)+exp(e12)+exp(e13)+exp(e14))
    a12= exp(e12)/(exp(e11)+exp(e12)+exp(e13)+exp(e14))
    a13= exp(e13)/(exp(e11)+exp(e12)+exp(e13)+exp(e14))
    a14= exp(e14)/(exp(e11)+exp(e12)+exp(e13)+exp(e14))
    

    由编码器隐藏状态hj与对齐得分a1j的乘积的线性和得到上下文向量C1:

    C1= h1 * a11 + h2 * a12 + h3 * a13 + h4 * a14
    


    连接上下文向量C1和目标隐藏状态s1,生成隐藏向量s1

    S1= concatenate([s1; C1])
    

    然后将注意力隐藏向量S1输入到稠密层,产生y1

    y1= dense(S1)
    

    我们可以用同样的方法计算Y2。

    实施

    在本文中,我们将使用亚马逊食品评论数据集。让我们来看看数据:

    https://www.kaggle.com/snap/amazon-fine-food-reviews

    数据清洗

    我们首先需要清理我们的数据,所以我们需要遵循的步骤是:

    将所有内容转换为小写字母
    删除HTML标记
    收缩映射
    删除(的)
    删除括号()内的任何文本
    消除标点和特殊字符
    删除stopwords。
    删除短词

    数据分布

    然后,我们将分析评语和总结的长度,从而对文章的长度分布有一个总体的认识。这将帮助我们确定序列的最大长度。

    标记数据:

    记号赋予器构建词汇表并将单词序列转换为整数序列。我们将使用Keras’ Tokenizer来标记句子。

    模型建立

    我们终于到了模型制作部分。但在此之前,我们需要熟悉一些术语,这些术语在构建模型之前是必需的。

    • Return Sequences= True:当参数设置为True时,LSTM为每个时间步长生成隐藏状态和单元格状态
    • Return State = True:当Return State = True时,LSTM只生成最后一个时间步骤的隐藏状态和单元格状态
    • Initial State:用于初始化第一个时间步骤的LSTM的内部状态
    • Stacked LSTM:Stacked LSTM有多层的LSTM堆叠在彼此之上。这样可以更好地表示序列。我鼓励您试验堆叠在彼此之上的LSTM的多个层

    训练和Early Stopping:

    这就是在训练过程中验证损失减少的原因,我们可以推断在 epoch10之后验证损失略有增加。因此,在这个 epoch之后,我们将停止训练模型。

    推理

    现在,我们将为编码器和解码器建立推断。在这里,编码器和解码器将一起工作,以产生摘要。所述解码器将堆叠在所述编码器之上,所述解码器的输出将再次馈入所述解码器以产生下一个字。

    Review: right quantity japanese green tea able either drink one sitting save later tastes great sweet  
    Original summary: great japanese product  
    Predicted summary:  great teaReview: love body wash smells nice works great feels great skin add fact subscribe save deal great value sold
    Original summary: great product and value  
    Predicted summary:  great productReview: look like picture include items pictured buy gift recipient disappointed  
    Original summary: very disappointed  
    Predicted summary:  not what expected
    

    总结

    在本文中,我们了解了如何使用序列到序列模型总结文本。我们可以通过增加数据集、使用双向LSTM、 Beam Search策略等方法进一步改进该模型。

    本文代码:https://gist.github.com/sayakmisra/6133be0554ce916d8cae4cdb83d475d8

    作者:Sayak Misra

    展开全文
  • 注意力模型

    千次阅读 2017-12-17 22:16:08
    注意力模型初见 注意力模型的思考 1.RNN原理理解 前两篇文章,我们详细讲解了RNN的原理:循环神经网络(RNN)原理通俗解释,以及它的高级版本LSTM:循环神经网络(RNN)之LSTM 这是它的原理图,你会发现,t−1,t,...
  • 参考: 睿智的seq2seq模型3——注意力机制概念详解与其在LSTM中的使用 bilibili视频
  • 与以往的事件检测方法相比,本文将两类任务视作同一个任务,避免了上游任务对下游任务的影响,使用神经网络学习特征,引入注意力机制突出重点信息。在MELL语料上进行生物事件抽取实验,结果表明准确率和召回率较高,...
  • 对于语音的情感识别,针对单层长短期记忆(LSTM)网络在解决复杂问题时的泛化能力不足,提出一种嵌入自注意力机制的堆叠LSTM模型,并引入惩罚项来提升网络性能。对于视频序列的情感识别,引入注意力机制,根据每个视频帧所...
  • 其中序列编码器基于双向LSTM,将词向量转换成中间隐含层序列输出,注意力模块置于隐含层输出的顶部,其中比较特殊的是,本结构中加入目标级别的注意力模块该模块的输入不是序列全部的中间隐含层输出,而是序列中描述...
  • 文章目录参考文献语言模型word2vec循环神经网络:RNNBi-LSTMLSTM长短期记忆,GRUSeq2seq注意力 参考文献 知乎链接 [1]基于深度学习的智能问答系统研究 语言模型 统计语言模型和神经网络语言模型。 N-gram 是统计语言...
  • 针对该问题,构建了融合主题特征的深层注意力LSTM模型(deeper attention LSTM with aspect embedding,AE-DATT-LSTM),通过共享权重的双向LSTM将主题词向量和文本词向量进行训练,得到主题特征和文本特征进行...
  • 尽管自注意力机制在这里和BiLSTM在处理词...第二,BiLSTM这种处理序列的模型,如果不计算出前一个时刻的结果,就没法计算下一个时刻的结果,所以就造成了无法并行计算,但是自注意力机制因为计算相似度也是不存在这种
  • 将文本信息向量化,提取文本局部特征,再将文本局部特征导入双向LSTM模型中,通过注意力机制对LSTM模型的输入与输出之间的相关性进行重要度计算,根据重要度获取文本整体特征;最后将局部特征和整体特征进行特征融合...
  • 本文提出基于注意力机制的双向LSTM用于负荷预测,简称BiLSTM-Attention, 提出了一种基于 Attention 机制的BiLSTM短期电力负荷预测方法,该方法将历史负荷数据作为输入,建模学习特征内部动态变化规律,并引入...
  • 探索基于注意和基于胶囊路由的层聚合和隐藏状态聚合 看到项目报告和演示幻灯片 主要要求 脾气暴躁的 火炬1.3 HuggingFace的v2.2.2 学分 除了HuggingFace的库外,我们还使用作为参考。 帮助培训了一些模型,准备了...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 341
精华内容 136
关键字:

lstm注意力模型