step by step带你HAN文本分类

Posted 2021-03-03 lihanlin

本文参考原文-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