attention 订阅
《Attention》是美国男歌手Charlie Puth演唱的一首歌曲,发行于2017年4月21日 [1]  ,收录于Charlie Puth2018年5月11日发行的录音室专辑《Voicenotes》中。 展开全文
《Attention》是美国男歌手Charlie Puth演唱的一首歌曲,发行于2017年4月21日 [1]  ,收录于Charlie Puth2018年5月11日发行的录音室专辑《Voicenotes》中。
信息
歌曲时长
3分31秒
歌曲原唱
Charlie Puth
中文名称
注意 [1]
发行时间
2017年4月21日
谱    曲
Jacob Kasher [2]  ,Charlie Puth [2]
音乐风格
流行摇滚,节奏蓝调,放克
外文名称
Attention
所属专辑
Voicenotes [2]
歌曲语言
英语
填    词
Jacob Kasher [2]  ,Charlie Puth [2]
attention中英歌词
收起全文
精华内容
参与话题
问答
  • attention

    2019-03-19 21:57:57
    文章目录Attention基本的Attention原理参考Hierarchical Attention原理实践参考Self Attentionother Attention Attention Attention是一种机制,可以应用到许多不同的模型中,像CNN、RNN、seq2seq等。Attention通过...

    Attention

    Attention是一种机制,可以应用到许多不同的模型中,像CNN、RNN、seq2seq等。Attention通过权重给模型赋予了区分辨别的能力,从而抽取出更加关键及重要的信息,使模型做出更加准确的判断,同时不会对模型的计算和存储带来更大的开销。

    基本的Attention原理

    下面通过seq2seq模型中的Attention介绍Attention的原理。

    seq2seq是RNN的一种变体,其不限制输入和输出的长度,是一种Encoder-Decoder的结构。未引入attention机制的seq2seq的结构如图

    image

    简化图如下

    image

    上图展示了将德语翻译成英语时的模型结构。encoder RNN(红色) 将输入语句信息编码到最后一个hidden vector中,并将其作为decoder(蓝色)初始的hidden vector,利用decoder解码成对应的其他语言中的文字。

    但对于较长的序列输入,由于长程梯度问题,最后的hidden vector不能保持所有的有效信息。通过引入attention机制,解决了长序列到定长向量转化时信息损失的瓶颈。引入attention机制后的动态图如下

    image

    下面给出数学上的运算过程

    image

    首先通过输入获得encoder中的隐状态image

    接着计算每一个encoder的隐状态decoder中各个时刻的隐状态的关联性。现考虑decoder中t-1时刻的隐状态与encoder中每一个隐状态j的关联性。
    image,写成相应的向量形式image。其中a是一种相关性的算符,例如常见的有点乘形式image ,加权点乘image ,加和image 等等。

    然后image 进行softmax操作将其normalize得到attention的分布,即 image ,展开形式为 image

    再然后利用求得的image对encoder中的所有隐状态进行加权求和得到decoder中各个时刻的隐状态对应的上下文向量image

    最后根据求得的上下文向量,可以求得decoder中t时刻(下一时刻)的隐状态image该位置的输出image

    上述过程中,通过获取encoder与decoder隐状态间的关联性从而获取attention分布是关键。 通过观察attention权重矩阵的变化,可以更好地知道哪部分翻译对应哪部分源文字,如下图所示

    image

    Attention机制的引入,打破了之前只能利用encoder最终单一向量结果的限制,从而使模型可以集中在所有对于下一个目标单词重要的输入信息上,使模型效果得到极大的改善。

    参考

    Attention机制详解(一)——Seq2Seq中的Attention

    Hierarchical Attention

    原理

    上面讲的在机器翻译中,seq2seq模型中的attention是基于源(encoder)与目标(decoder)的相关程度展开的,但是在文本分类中,只有源(原文),没有目标,在这种情况下,就需要attention的变种技术,叫self-Attention。即源(原文)自己内部的注意力机制。

    self-Attention有不同的做法。比如Attention is All You Need中,相比之前的seq2seq模型中的attention,在机器翻译任务中,不仅去掉了rnn部分,全部换成attention,还通过把attention机制形式化成Key-Value的形式,表达了源语言和目标语言各自内部的注意力机制。这样做有利于更好的把控句子的结构和意义。变动后的模型就是大名鼎鼎的transformer。内部attention的可视化示意图如下:

    image

    在文本分类(Hierarchical Attention Networks for Document Classification)中,通过引入context vector uw(词级别的context vector) 和us(句级别的context vector)[待学习的参数] 来实现self-attention,从而找到高权重的词语和句子。

    其主要思想是,首先考虑文档的分层结构:单词构成句子,句子构成文档,所以建模时也分这两部分进行。其次,句子中的不同单词和文档中的不同句子对文本分类来说分别具有不同的重要性,不能单纯的统一对待,所以引入Attention机制。而且引入Attention机制除了提高模型的精确度之外还可以进行单词、句子重要性的分析和可视化,让我们对文本分类的内部有一定了解。模型结构如下图所示:

    image

    其主要由下面四个部分构成

    • a word sequence encoder

    image

    • a word-level attention layer

    image

    • a sentence encoder

    image

    • a sentence-level attention layer

    image

    实践

    在每一轮下的每一个批次(固定数量的文本数)中,首先通过选取当前批次下所有文档中最多的句子数以及所有句子中多的单词数来确定当前批次句子和词的维度。从而确定待训练数据的三个维度:文档数、句子数(最多,不足补0)、单词数(最多,不足补0),接着将待训练数据输入到嵌入层(embedding),获取word_embedding,并将word_embedding作为输入传到tf.nn.bidirectional_dynamic_rnn中,将到tf.nn.bidirectional_dynamic_rnn的输出作为attention的输入,求出词级别的attention输出,并将其作为sentence_embedding的输入再次传入到tf.nn.bidirectional_dynamic_rnn中,从而获取句级别的attention输出最后将得到的sentence_embedding的输出全连接到神经元个数为种类个数的输出层,从而得到预测的种类。

    model

    from utils import *
    import tensorflow as tf
    from attention import attention
    class hier_rnn():
        def __init__(self,args):
            self.args=args
            self.sentence=tf.placeholder(tf.int32,[self.args.batch_size,None,None])
            self.target=tf.placeholder(tf.int64,[self.args.batch_size])
            self.seq_len=tf.placeholder(tf.int32,[None])
            self.max_len=tf.placeholder(tf.int32,shape=())
    
        def word_embedding(self,input):
            def cell():
                return tf.nn.rnn_cell.GRUCell(128)
    
            cell_bw=cell_fw=tf.nn.rnn_cell.MultiRNNCell([cell() for _ in range(3)])
            outputs,_=tf.nn.bidirectional_dynamic_rnn(cell_fw,cell_bw,input,
                                                      sequence_length=self.seq_len,dtype=tf.float32,
                                                      scope='word_embedding')
            return attention(outputs,128)
    
        def sentence_embedding(self,input):
            def cell():
                return tf.nn.rnn_cell.GRUCell(128)
    
            cell_bw=cell_fw=tf.nn.rnn_cell.MultiRNNCell([cell() for _ in range(3)])
            cell_fw_initial=cell_fw.zero_state(self.args.batch_size,tf.float32)
            cell_bw_initial=cell_bw.zero_state(self.args.batch_size,tf.float32)
            outputs,_=tf.nn.bidirectional_dynamic_rnn(cell_fw,cell_bw,input,
                                                      initial_state_fw=cell_fw_initial,
                                                      initial_state_bw=cell_bw_initial,
                                                      scope='sentence_embedding')
            return attention(outputs,128)
    
        def forward(self):
            # time_step=self.sentence.shape[2].value
            sen_in=tf.reshape(self.sentence,[self.args.batch_size*self.max_len,-1])
            with tf.device("/cpu:0"):
                embedding=tf.get_variable('embedding',shape=[89526,256])
                inputs=tf.nn.embedding_lookup(embedding,sen_in)
            word_embedding=self.word_embedding(inputs)
            word_embedding=tf.reshape(word_embedding,[self.args.batch_size,-1,256])
    
            sen_embedding=self.sentence_embedding(word_embedding)
            logits=tf.layers.dense(sen_embedding,2)
    
            cross_entropy=tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(
                labels=self.target,logits=logits))
    
            optimizer=tf.train.AdamOptimizer().minimize(cross_entropy)
            correct=tf.equal(self.target,tf.argmax(tf.nn.softmax(logits),axis=1))
            accuracy=tf.reduce_mean(tf.cast(correct,tf.float32))
            return cross_entropy,optimizer,accuracy
    
        def train(self):
            cross_entropy,optimizer,accuracy=self.forward()
            with tf.Session() as sess:
                sess.run(tf.global_variables_initializer())
                for epoch in range(10):
                    x_batch,y_batch,seq_len,max_len=next_batch(self.args.batch_size)
                    for step in range(len(x_batch)):
                        # print(y_batch[step])
                        # print(y_batch[step])
                        loss,_,acc=sess.run([cross_entropy,optimizer,accuracy],
                                            feed_dict={self.sentence:x_batch[step],
                                                       self.target:y_batch[step],
                                                       self.seq_len:seq_len[step],#单词数
                                                       self.max_len:max_len[step]})#句子数
                        if step%10==0:
                            print("Epoch %d,Step %d,loss is %f"%(epoch,step,loss))
                            print("Epoch %d,Step %d,accuracy is %f"%(epoch,step,acc))
                    x_batch,y_batch,seq_len,max_len=next_batch(self.args.batch_size,mode='test')
                    test_accuracy=0
                    for step in range(len(x_batch)):
                        acc=sess.run(accuracy,feed_dict={self.sentence:x_batch[step],
                                                         self.target:y_batch[step],
                                                         self.seq_len:seq_len[step],
                                                         self.max_len:max_len[step]})
                        test_accuracy+=acc
                    print('test accuracy is %f'%(test_accuracy/len(x_batch)))
    
    

    attention

    import tensorflow as tf
    
    def attention(inputs,attention_size):
        inputs=tf.concat(inputs,2)
    
        v=tf.layers.dense(inputs,attention_size,activation=tf.nn.tanh)
        vu=tf.layers.dense(v,1,use_bias=False)
        alphas=tf.nn.softmax(vu)
    
        output=tf.reduce_mean(alphas*inputs,axis=1)
        return output
    

    参考

    一个Hierarchical Attention神经网络的实现

    Hierarchical Attention Network for Document Classification阅读笔记

    Hierarchical Attention Network for Document Classification

    Self Attention

    Attention is All You Need中的self-attention把attention机制形式化成Key-Value的形式,属于transformer的一部分,在讲transformer时再详细展开。

    other Attention

    其他形式的attention见 深度学习中Attention Mechanism详细介绍:原理、分类及应用

    展开全文
  • Attention

    2019-07-17 15:35:21
    ATTENTION机制讲的比较经典的总结 完全图解RNN、RNN变体、Seq2Seq、Attention机制 https://www.leiphone.com/news/201709/8tDpwklrKubaecTa.html [译] 理解 LSTM 网络 https://www.jianshu.com/p/9dc9f41f0b29...

    对ATTENTION机制讲的比较经典的总结

    完全图解RNN、RNN变体、Seq2Seq、Attention机制

    https://www.leiphone.com/news/201709/8tDpwklrKubaecTa.html

    [译] 理解 LSTM 网络

    https://www.jianshu.com/p/9dc9f41f0b29

    自然语言处理中的Attention机制总结

     https://blog.csdn.net/hahajinbu/article/details/81940355

     

    展开全文
  • <div><p>Location Sensitive Attention(step 8500) <img alt="test-step-000008500-locationsensitive-attention" src=...
  • 纵观神经网络的发展历程,从最原始的MLP,到CNN,到RNN,到LSTM,GRU,再到现在的Attention机制,人们不断的在网络里面加入一些先验知识,使得网络不过于“发散”,能够朝着人们希望的方向去发展。 这些先验知识是指...

    前言

    纵观神经网络的发展历程,从最原始的MLP,到CNN,到RNN,到LSTM,GRU,再到现在的Attention机制,人们不断的在网络里面加入一些先验知识,使得网络不过于“发散”,能够朝着人们希望的方向去发展。
    这些先验知识是指:局部视野知识、序列递归知识、结构递归知识,已经长短时的记忆。现在,人们加入了注意力这种先验知识。

    本文将介绍应用在NLP领域的attention机制,包括传统的attention机制以及最新的transformer机制。

    啥子叫注意力?

    注意力机制可以看做一种通用的思想,是指人在工作的是注意力往往会集中在整个场景中的某些焦点上。

    举个例子哈,大家在中学做语文的阅读理解的时候,有一个常见的题目就是找整篇文章的中心句。这个时候,我们往往都把注意力集中在开头段、结尾段,中间的内容不是说不重要,但是在找中心句的时候,我们往往把注意力偏重于开头结尾。这就是一种注意力的体现。

    再举个例子:
    在这里插入图片描述
    这是一种街景图,假设现在我们处在这个场景中,我想找周围有没有超市,那么对于这么一个映入我眼睑的图像,我肯定会认为超市应该在街道的两边,不会在空中。于是,我会把我的注意力集中在前方的左右两边的商店。

    又比如,还是在这个场景中,假设开车在这条道路上,急着去见妹纸,那么我的注意力自然就是红绿灯咯。

    这两个例子基本就能体现出注意力机制的核心思想:对于一个复杂的输入,不同的问题会把注意力侧重于不同的地方。

    那再看看在机器翻译的一个小小的attention的例子。
    在这里插入图片描述
    这是一个很典型的基于RNN网络的机器翻译模型,模型先依次往网络输入 Tom,Chase,Jerry,然后最后得到待翻译句子的向量表达CC,这个CC理应结合了输入的所有信息。然后翻译的时候,“汤姆”就基于CC给计算出来了。
    但是,我们隐隐约约感受到这样的模型似乎在翻译成“汤姆”的时候,把Tom chase Jerry 这三个词都视为同等重要来翻译,但实际上 这个词的翻译的 注意力应该在“Tom”这个词的附近。说的更直白一些,“汤姆”这个翻译结果对输入各个词的关注度应该有所侧重,如果用权重衡量的话,Tom 可能占用了0.7的关注度,其他两个词可能分别占用0.2和0.1的关注度。

    基本思想就是这样子的了,通过关注度的高低大小来体现注意力的倾向。

    注意力机制核心思想

    假设,(Ki,Vi)(K_{i},V_{i})KiK_{i}表示输入的一部分,ViV_{i}表达输入的一部分。现在在某个任务的时候,我们给输入的各个ViV_{i}有个打分αi\alpha_{i},那些任务高度关注的ViV_{i}打分就高。那么应该怎么做?

    在这里插入图片描述
    如上图所示,做的方法很简单的,首先QQ表示一个与当前任务有关的矩阵,它可以协助选择出那个ViV_{i}的权重大。
    于是先拿QQKiK_{i} 做一次f(Q,Ki)f(Q,K_{i})运算得到不同SiS_{i},然后在对这些SiS_{i}进行归一化,得到对应的规范权重。最后,在依这些权重计算V1,V2,V5V_{1},V_{2}\dots,V_{5}的线性组合AttVAtt-V
    通常,K和V是相等的。
    而这个加权后V1,V2,V5V_{1},V_{2}\dots,V_{5}的线性组合AttVAtt-V就是传说中的注意力值,这个值就对V1,V2,V5V_{1},V_{2}\dots,V_{5}这几个值有所侧重。

    我们再看打分函数f(Q,K)f(Q,K)一般是那些函数:
    在这里插入图片描述
    它可以是个标注向量内积,也可以是椭圆内积,或者concat,当然也可以专门设计一个小型的MLP来完成这个f的功能。
    使用MLP来实现f函数

    注意力的分类

    求注意力的时候,不同分配限制会有不同的注意力。
    例如:

    软注意力

    对概率的分配没有任何限制。
    在这里插入图片描述

    硬注意力:

    在软注意力的基础上对概率分配添加某种限制,例如:限制概率最大的那个αi\alpha_{i}为1,其他强制改为0。

    在这里插入图片描述
    然后考虑计算Attention是基于输入的全部还是局部又分为全局注意力。

    全局注意力

    Decoder段在计算Attention是考虑Encoder的所有词。
    在这里插入图片描述
    这样得到的注意力值Att-V 是全局输入向量的依各列相应概率值的线性组合。

    局部注意力

    与全局注意力形成对比的是,为了加快训练速度,可以设置一个窗口,使得对于输入的窗口内的向量进行打分,然后求这些窗口内的向量的线性组合。
    在这里插入图片描述

    Attention的具体应用

    见下一篇博客,专门解读2015年attention机制用于机器翻译的句嵌入表示的论文。

    展开全文
  • Extending Self Attention

    2020-12-02 23:27:27
    <div><p>I want to implement some changes to the self-attention used in the Transformer for MT, namely implement locality-sensitive hashing (https://arxiv.org/pdf/2001.04451.pdf). <p>Right now, self-...
  • Keras Attention Mechanism Simple attention mechanism implemented in Keras for the following layers: Dense (attention 2D block) LSTM, GRU (attention 3D block) Example: Attention block ...
  • 该文档主要介绍了attention及其变种self attention 、multi-attention以及一些相关的paper
  • 时隔半年多,毕设男孩终于重操旧业,回到了 LSTM进行时间序列预测和异常检测的路上。...本次我们要进行的是 使用 注意力机制 + LSTM 进行时间序列预测,项目地址为Keras Attention Mechanism 首先我们把它git...

    时隔半年多,毕设男孩终于重操旧业,回到了 LSTM进行时间序列预测和异常检测的路上。

    如果有阅读过我之前的博客,可以发现使用 LSTM作单类的时间序列异常检测也是基于对于时间序列的预测进行 登堂入室LSTM:使用LSTM进行简单的时间序列异常检测

    本次我们要进行的是 使用 注意力机制 + LSTM 进行时间序列预测,项目地址为Keras Attention Mechanism

    对于时间步的注意力机制

    首先我们把它git clone 到本地,然后配置好所需环境 笔者的 tensorflow版本为1.6.0 Keras 版本为 2.0.2
    打开文件夹,我们主要需要的是attention_lstm.py 以及 attention_utils.py 脚本

    项目中生成数据的函数为

    def get_data_recurrent(n, time_steps, input_dim, attention_column=10):
        """
        Data generation. x is purely random except that it's first value equals the target y.
        In practice, the network    should learn that the target = x[attention_column].
        Therefore, most of its attention should be focused on the value addressed by attention_column.
        :param n: the number of samples to retrieve.
        :param time_steps: the number of time steps of your series.
        :param input_dim: the number of dimensions of each element in the series.
        :param attention_column: the column linked to the target. Everything else is purely random.
        :return: x: model inputs, y: model targets
        """
        x = np.random.standard_normal(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
    

    默认的 n = 30000, input_dim = 2 ,timesteps = 20。生成的数据为:

    shape
    x 30000 x 20 x 2
    y 30000 x 1

    其中 x 的第11个 timestep 两维的数据 与y相同,其他timestep 维的数据为随机数。

    所以当我们使用这样的数据去进行 注意力机制 LSTM 的训练,我们希望得到的结果是 注意力层 主要关注第11个timestep 而对其他timestep 的关注度较低。

    直接运行 attention_lstm.py 脚本
    此时的网络结构为:
    在这里插入图片描述
    可以看到是在 LSTM 层之后使用了注意力机制

    最后会汇总画一张图
    在这里插入图片描述
    可以看到 可以看到注意力的权重主要汇总在了第11个timestep,说明注意力机制很成功

    对于维的注意力机制

    上述的例子 是将注意力机制使用在了 timestep 上,决定哪个时间步对于结果的影响较大。
    而如果我们想将 注意力机制使用在维上呢? 比如使用多维去预测一维的数据,我们想使用注意力机制
    决定哪些维对于预测维起关键作用。

    比较简单的方法就是将输入数据 reshape 一下 将timesteps 与 input_dim 维对换 再运行就可以了,因为本代码的设置就是对 输入的第2维加入注意力机制.

    进阶的方法就是 自写一下 attention_3d_block 函数:

    def attention_3d_block(inputs):
        # inputs.shape = (batch_size, time_steps, input_dim)
        input_dim = int(inputs.shape[2])
        a = inputs
        #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(input_dim, 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((1, 2), name='attention_vec')(a)
        #a_probs = a
        output_attention_mul = merge([inputs, a_probs], name='attention_mul', mode='mul')
        return output_attention_mul
    

    其实严格来讲我们所做的改变不多,作者使用了 Permute层对于数据进行了 第2和第3维的对换,我们则没有进行对换操作。

    接下来 再在attention_utils.py 脚本中写一个产生数据集的新函数:

    def get_data_recurrent2(n, time_steps, input_dim, attention_dim=5):
        """
        假设 input_dim = 10  time_steps = 6
        产生一个  x 6 x 10 的数据 其中每步的第 6 维 与 y相同
    
        """
        x = np.random.standard_normal(size=(n, time_steps, input_dim))
        y = np.random.randint(low=0, high=2, size=(n, 1))
        x[:,:,attention_dim] =  np.tile(y[:], (1, time_steps))
    
        return x,y
    

    试着产生一组数据 get_data_recurrent2(1,6,10)
    在这里插入图片描述

    然后我们稍微改动一下main函数进行新的训练。迭代十次后结果为:
    在这里插入图片描述
    可以看到,第6维的权重比较大。
    如果我们对于timesteps的注意力画一个汇总图,即改动一下

      attention_vector = np.mean(get_activations(m, testing_inputs_1,print_shape_only=False,layer_name='attention_vec')[0], axis=2).squeeze()
    

    可以看到对于timesteps的注意力是相同的(其实如果对于开头时间步的注意力机制,对输入维的注意力画一个汇总图,也是相同的)
    在这里插入图片描述

    对于时间步和输入维的注意力机制

    待补充

    注:参考 keras-attention-mechanism
    以及 Keras中文文档

    代码已上传到我的github

    展开全文
  • 自然语言处理中的Attention Model:是什么及为什么

    万次阅读 多人点赞 2016-01-20 18:26:02
    /* 版权声明:可以任意转载,转载时请标明文章原始出处和作者信息 .*/    author: 张俊林     (想更系统地学习深度学习知识?请参考:深度学习枕边书) ...要是关注深度学习在自然...
  • Attention机制与Self-Attention机制的区别

    万次阅读 2020-09-08 15:33:20
    本文主要讲解Attention机制与Self-Attention机制的区别,默认读者已经了解过Attention、Self-Attention、Transformer、seq2seq model。 传统的Attention机制在一般任务的Encoder-Decoder model中,输入Source和...
  • Attention Transfer

    2019-11-07 20:45:52
    Paying More Attention to Attention: Improving the Performance of Convolutional Neural Networks via Attention Transfer Motivation 大量的论文已经证明Attention在CV、NLP中都发挥着巨大的作用,因为本文利用...
  • AttentionAttention

    千次阅读 2019-06-14 15:24:13
    下文主要是结合自己的理解翻译自:AttentionAttention! 注意力(Attention)在近些年成为深度学习领域一个极其受欢迎的概念,同时作为一个强有力的工具也被集成到了各种模型中来处理相应的任务。下面将介绍注意...
  • Attention Mechanism Can I have your Attention please! The introduction of the Attention Mechanism in deep learning has improved the success of various models in recent years, and continues to be an.....
  • 自然语言处理中的Attention机制总结

    万次阅读 多人点赞 2018-08-22 15:20:57
    在面试的过程中被问到了attention,原来虽然其实已经实际用过attention了,也知道个大概原理是加权求和,但是对于加权的具体方法以及权值得分的计算并不是很清晰,面试答的一般,正好最近实习的地方

空空如也

1 2 3 4 5 ... 20
收藏数 18,688
精华内容 7,475
关键字:

attention