step by step带你HAN文本分类

本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6302/

今天来看看网红Attention的效果，来自ACL的论文Hierarchical Attention Networks for Document Classification

**论文概述

**


近年来，在NLP领域，好像最流行的就是RNN、LSTM、GRU、Attention等及其变体的组合框架。这篇论文里作者就对文本的结构进行分析，使用了双向GRU的结构，并且对Attention进行调整：考虑了word层面的attention和sentence层面的attention，分别对单词在句子中和句子在文档中的重要性进行了建模。仔细一想确实是挺合理的，一篇文档就是由无数句子构成的，而一个句子又是由无数单词构成的，充分考虑了文档的内部结构。

上图就是论文中文本分类模型的整体框架，可以看出主要分为四个部分：

  • word encoder （BiGRU layer）
  • word attention （Attention layer）
  • sentence encoder （BiGRU layer）
  • sentence attention （Attention layer）

首先回顾一下GRU的原理：

GRU是RNN的一个变种，使用门机制来记录当前序列的状态。在GRU中有两种类型的门（gate）:reset gate和update gate。这两个门一起控制来决定当前状态有多少信息要更新。

reset gate是用于决定多少过去的信息被用于生成候选状态，如果Rt为0，表明忘记之前的所有状态：

根据reset gate的分数可以计算出候选状态：

update gate是用来决定有多少过去的信息被保留，以及多少新信息被加进来：

最后，隐藏层状态的计算公式，有update gate、候选状态和之前的状态共同决定：

接着来回顾一下Attention原理：

好啦，下面具体来看看论文里的模型：

1、word encoder layer

首先，将每个句子中的单词做embedding转换成词向量，然后，输入到双向GRU网络中，结合上下文的信息，获得该单词对应的隐藏状态输出

2、word attention layer

attention机制的目的就是要把一个句子中，对句子表达最重要的单词找出来，赋予一个更大的比重。

首先将word encoder那一步的输出得到的输入到一个单层的感知机中得到结果作为其隐含表示

接着为了衡量单词的重要性，定义了一个随机初始化的单词层面上下文向量，计算其与句子中每个单词的相似度，然后经过一个softmax操作获得了一个归一化的attention权重矩阵，代表句子i中第t个单词的权重：

于是，句子的向量Si就可以看做是句子中单词的向量的加权求和。这里的单词层面上下文向量是随机初始化并且可以在训练的过程中学习得到的，我们可以把它看成是一种query的高级表示：“句子中哪些词含有比较重要的信息？”

3、sentence encoder

通过上述步骤我们得到了每个句子的向量表示，然后可以用相似的方法得到文档向量

4、sentence attention

和词级别的attention类似，作者提出了一个句子级别的上下文向量,来衡量一个句子在整篇文本的重要性。

5、softmax

上面的v向量就是我们得到的最后文档表示，然后输入一个全连接的softmax层进行分类就ok了。

6、模型效果

代码实现

定义模型

class HAN(object):
    def __init__(self, max_sentence_num, max_sentence_length, num_classes, vocab_size,
                 embedding_size, learning_rate, decay_steps, decay_rate,
                 hidden_size, l2_lambda, grad_clip, is_training=False,
                 initializer=tf.random_normal_initializer(stddev=0.1)):
        self.vocab_size = vocab_size
        self.max_sentence_num = max_sentence_num
        self.max_sentence_length = max_sentence_length
        self.num_classes = num_classes
        self.embedding_size = embedding_size
        self.hidden_size = hidden_size
        self.learning_rate = learning_rate
        self.decay_rate = decay_rate
        self.decay_steps = decay_steps
        self.l2_lambda = l2_lambda
        self.grad_clip = grad_clip
        self.initializer = initializer
        self.global_step = tf.Variable(0, trainable=False, name=‘global_step‘)
        # placeholder
        self.input_x = tf.placeholder(tf.int32, [None, max_sentence_num, max_sentence_length], name=‘input_x‘)
        self.input_y = tf.placeholder(tf.int32, [None, num_classes], name=‘input_y‘)
        self.dropout_keep_prob = tf.placeholder(tf.float32, name=‘dropout_keep_prob‘)
        if not is_training:
            return
        word_embedding = self.word2vec()
        sen_vec = self.sen2vec(word_embedding)
        doc_vec = self.doc2vec(sen_vec)
        self.logits = self.inference(doc_vec)
        self.loss_val = self.loss(self.input_y, self.logits)
        self.train_op = self.train()
        self.prediction = tf.argmax(self.logits, axis=1, name=‘prediction‘)
        self.pred_min = tf.reduce_min(self.prediction)
        self.pred_max = tf.reduce_max(self.prediction)
        self.pred_cnt = tf.bincount(tf.cast(self.prediction, dtype=tf.int32))
        self.label_cnt = tf.bincount(tf.cast(tf.argmax(self.input_y, axis=1), dtype=tf.int32))
        self.accuracy = self.accuracy(self.logits, self.input_y)
  • END -

The End

原文地址：https://www.cnblogs.com/lihanlin/p/12571867.html

时间： 2024-10-01 21:41:34

step by step带你HAN文本分类的相关文章

带监督的文本分类算法FastText

该算法由facebook在2016年开源,典型应用场景是"带监督的文本分类问题". 模型 模型的优化目标如下: 其中,$<x_n,y_n>$是一条训练样本,$y_n$是训练目标,$x_n$是normalized bag of features.矩阵参数A是基于word的look-up table,也就是A是词的embedding向量.$Ax_n$矩阵运算的数学意义是将word的embedding向量找到后相加或者取平均,得到hidden向量.矩阵参数B是函数f的参数,函数f

step by step带你fastText文本分类

本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6300/ **写在前面 ** 今天的教程是基于FAIR的Bag of Tricks for Efficient Text Classification[1].也就是我们常说的fastText. 最让人欣喜的这篇论文配套提供了fasttext工具包.这个工具包代码质量非常高,论文结果一键还原,目前已经是包装地非常专业了,这是fastText官网和其github代码库,以及提供了python接口,可以直接

step by step带你RCNN文本分类

本文参考原文-http://bjbsair.com/2020-03-25/tech-info/6304/ **传统文本分类 ** 之前介绍的都是属于深度神经网络框架的,那么在Deep Learning出现或者风靡之前,文本分类是怎么做的呢? 传统的文本分类工作主要分为三个过程:特征工程.特征选择和不同分类机器学习算法. 1.1 特征工程 对于文本数据的特征工程来说,最广泛使用的功能是bag-of-words.tf-idf等.此外,还可以设计一些更复杂的特征,比如词性标签.名词短语以及tree k

机器学习基础——带你实战朴素贝叶斯模型文本分类

本文始发于个人公众号:TechFlow 上一篇文章当中我们介绍了朴素贝叶斯模型的基本原理. 朴素贝叶斯的核心本质是假设样本当中的变量服从某个分布,从而利用条件概率计算出样本属于某个类别的概率.一般来说一个样本往往会含有许多特征,这些特征之间很有可能是有相关性的.为了简化模型,朴素贝叶斯模型假设这些变量是独立的.这样我们就可以很简单地计算出样本的概率. 想要回顾其中细节的同学,可以点击链接回到之前的文章: 机器学习基础--让你一文学会朴素贝叶斯模型 在我们学习算法的过程中,如果只看模型的原理以及理

LingPipe-TextClassification(文本分类)

What is Text Classification? Text classification typically involves assigning a document to a category by automated or human means. LingPipe provides a classification facility that takes examples of text classifications--typically generated by a huma

2017知乎看山杯总结(多标签文本分类)

http://blog.csdn.net/jerr__y/article/details/77751885 关于比赛详情,请戳:2017 知乎看山杯机器学习挑战赛 代码:https://github.com/yongyehuang/zhihu-text-classification 基于:python 2.7, TensorFlow 1.2.1 任务描述:参赛者需要根据知乎给出的问题及话题标签的绑定关系的训练数据,训练出对未标注数据自动标注的模型. 标注数据中包含 300 万个问题,每个问题有

Spark ML下实现的多分类adaboost+naivebayes算法在文本分类上的应用

1. Naive Bayes算法 朴素贝叶斯算法算是生成模型中一个最经典的分类算法之一了,常用的有Bernoulli和Multinomial两种.在文本分类上经常会用到这两种方法.在词袋模型中,对于一篇文档$d$中出现的词$w_0,w_1,...,w_n$, 这篇文章被分类为$c$的概率为$$p(c|w_0,w_1,...,w_n) = \frac{p(c,w_0,w_1,...,w_n)}{p(w_0,w_1,...,w_n)} = \frac{p(w_0,w_1,...,w_n|c)*p(c

Step by Step 改进朴素贝叶斯算法

引言 如果你对naive bayes认识还处于初级阶段,只了解基本的原理和假设,还没有实现过产品级的代码,那么这篇文章能够帮助你一步步对原始的朴素贝叶斯算法进行改进.在这个过程中你将会看到朴素贝叶斯假设的一些不合理处以及局限性,从而了解为什么这些假设在简化你的算法的同时,使最终分类结果变得糟糕,并针对这些问题提出了改进的方法. 朴素贝叶斯(Naive Bayes) 出处: <机器学习>(Machine Learning by Tom M.Mitchell) 符号和术语 假设待分类的实例 X 可

Tensorflor实现文本分类

Tensorflor实现文本分类 下面我们使用CNN做文本分类 cnn实现文本分类的原理 下图展示了如何使用cnn进行句子分类.输入是一个句子,为了使其可以进行卷积,首先需要将其转化为向量表示,通常使用word2vec实现.d=5表示每个词转化为5维的向量,矩阵的形状是[sentence_length × 5],即[7 ×5].6个filter(卷积核),与图像中使用的卷积核不同的是,nlp使用的卷积核的宽与句子矩阵的宽相同,只是长度不同.这里有(2,3,4)三种size,每种size有两个fi