本课程来自深度之眼deepshare.net，部分截图来自课程视频。
文章标题：Hierarchical Attention Network for Document Classification
原标题翻译：用于文本分类的层次注意力网络
作者：zichao Yang，Diyi Yang，Chris Dyer，Xiaodong He， Alex Smola，Eduard Hovy
单位：卡耐基梅隆大学，微软研究院
Carnegie Mellon University, Microsoft Research, Redmond
论文来源：NAACL 2016
在线LaTeX公式编辑器
文本挖掘：是一个以半结构或者无结构的自然语言文本为对象的数据挖掘，是从大规模文本数据集中发现隐藏的、重要的、新颖的、潜在的、有用的规律的过程。
·文本分类是文本挖掘的一个常见任务。
非结构化数据：没有固定结构的数据，直接整体进行存储，一般存储为二进制的数据格式。
半结构化数据：结构化数据的一种形式，它并不符合关系型数据库等形式关联起来的数据模型结构，但包含相关标记，用来分割语义元素以及对记录和字段进行分层。
结构化数据：能够用数据或统一的结构加以表示，如数字、符号。通常的形式是二维表。
文本分类是自然语言处理的基本任务。目标是将非结构化文档（例如，评论，电子邮件，帖子，网站内容等）分配给一个或多个类。
文本分类流程：
文本数据获取
文本预处理
文本的向量表示
构造分类器
模型评估
常见的文本分类应用：
主题标记
·产品营销
·产品评论
·内容标记
情感分析：情感分析预测了基于文本分类的特定特征的情绪。
信息检索（lR）所有文本分类问题的基础。IR基本算法：
词袋模型：按照词出现的频率表示文本
TF-IDF算法：按比率设置词频和逆向文件频率，通过出现的词的相关性来表示文本
N-gram模型：计算一组共同出现的词
其他早期无监督方法：
（半）监督方法
深度之眼Paper带读笔记NLP.8：TextCNN.Baseline.04https://blog.csdn.net/oldmao_2001/article/details/101170988
深度之眼Paper带读笔记NLP.9：基于CNN的词级别的文本分类.Baseline.05.https://blog.csdn.net/oldmao_2001/article/details/101275082
深度之眼Paper带读笔记NLP.11：FASTTEXT.Baseline.06 https://blog.csdn.net/oldmao_2001/article/details/101615439
优点：
• 效果特别好，基本都是sota的结果。
• 不需要做特征工程。
忽视的问题：
• 文档中不同句子对于分类的重要性不同。（未考虑句子的重要性红色部分）
• 句子中不同单词对于分类的重要性也有所不同。（未考虑词的重要性蓝色部分）
因此，需要分层注意网络来解决这两个问题。下面稍微介绍一下，后面详细讲。
信息重要度：并非句子中的每个单词和文档中的每个句子对于理解文档的主要信息同样重要。
上下文语境：单词的含义需要根据不同的上下文做出不同的判断。
例如：pretty
·The bouquet of flowers is pretty.
·The food is pretty bad.
结论：并非文档中的所有部分都能从中获得同等重要的本质信息
文本分类：了解文本分类任务的基本概念和应用种类，以及任务流程。
概率论：了解基本的概率论知识，掌握条件概率的概念和公式。
注意力机制：了解注意力机制的概念和种类，掌握注意力机制的计算方法。
循环神经网络：了解循环神经网络的结构，掌握它的基本工作原理。
本小节首先介绍了论文的整体框架，这部分我们根据论文结构和摘要理清作者的写研究和写作思路；然后讲解了层次注意力网络模型HAN，这部分我们讲解层次注意力网络的构成和计算方式。之后讲解了论文实验中的一些设置和并且分析了实验结果。最后我们进行了论文的讨论和总结，并展望该领域未来的发展方向。
Text classification is one of the fundamental task in Natural Language Processing. The goal is to assign labels to text. It has broad applications including topic labeling (Wang and Manning, 2012), sentiment classification (Maas et al., 2011; Pang and Lee, 2008), and spam detection (Sahami et al., 1998). Traditional approaches of text classification represent documents with sparse lexical features, such as n-grams, and then use a linear model or kernel methods on this representation (Wang and Manning, 2012; Joachims, 1998). More recent approaches used deep learning, such as convolutional neural networks (Blunsom et al., 2014) and recurrent neural networks based on long short-term memory (LSTM) (Hochreiter and Schmidhuber, 1997) to learn text representations.
摘要
网络组成结构：
·word encoder：单词序列编码器
·word attention：单词注意力机制
·sentence encoder：句子编码器
·sentence attention：句子注意力机制
·RNN的一个变种，使用门机制来记录序列当前的状态。
·隐藏层状态的计算公式：
h
t
=
(
1
−
z
t
)
⊙
h
t
−
1
+
z
t
⊙
h
~
t
h_t=(1-z_t)\odot h_{t-1}+z_t\odot \tilde h_t
ht=(1−zt)⊙ht−1+zt⊙h~t（这个公式表示新的状态保留多少，旧的状态保留多少。）
·更新门：
z
t
=
σ
(
W
z
x
t
+
U
z
h
t
−
1
+
b
z
)
z_t=\sigma(W_zx_t+U_zh_{t-1}+b_z)
zt=σ(Wzxt+Uzht−1+bz)
·候选状态：
h
~
t
=
t
a
n
h
(
W
h
x
t
+
r
t
⊙
(
U
h
h
t
−
1
)
+
b
h
)
\tilde h_t=tanh(W_hx_t+r_t\odot(U_hh_{t-1})+b_h)
h~t=tanh(Whxt+rt⊙(Uhht−1)+bh)
·重置（遗忘）门：
r
t
=
σ
(
W
r
x
t
+
U
r
h
t
−
1
+
b
r
)
r_t=\sigma(W_rx_t+U_rh_{t-1}+b_r)
rt=σ(Wrxt+Urht−1+br)
GRU比LSTM少一个cell，用于记忆之前的信息
·
x
i
t
x_{it}
xit：单词的词向量
·
h
i
t
h_{it}
hit：隐层状态
x
i
t
=
W
e
w
i
t
,
t
∈
[
1
,
T
]
,
(1)
x_{it}=W_ew_{it}, t \in [1, T],\tag1
xit=Wewit,t∈[1,T],(1)
W
e
W_e
We是词向量矩阵，
w
i
t
w_{it}
wit是独热编码，两个相乘得到是词向量，t是时间步或者说第几个词，i代表当前第几个句子
h
i
t
→
=
G
R
U
→
(
x
i
t
)
,
t
∈
[
1
,
T
]
,
(2)
\overrightarrow{h_{it}}=\overrightarrow{GRU}(x_{it}), t \in [1, T],\tag2
hit
=GRU
(xit),t∈[1,T],(2)
上面是前向GRU
h
i
t
←
=
G
R
U
←
(
x
i
t
)
,
t
∈
[
1
,
T
]
,
(3)
\overleftarrow{h_{it}}=\overleftarrow{GRU}(x_{it}), t \in [1, T],\tag3
hit
=GRU
(xit),t∈[1,T],(3)
上面是反向GRU
h
i
t
=
[
h
i
t
→
,
h
i
t
←
]
(4)
h_{it}=[\overrightarrow{h_{it}},\overleftarrow{h_{it}}]\tag4
hit=[hit
,hit
](4)
上面是前向和反向GRU的concat
首先假设一个文档有L个句子，每个句子
S
i
S_i
Si包含有
t
i
t_i
ti个单词，句子的总长度为T
整个网络输入
W
i
t
W_{it}
Wit表示第i个句子中的第t个单词（就是上图画红线部分）。然后利用矩阵
W
e
W_e
We和独热编码
w
i
t
w_{it}
wit把单词embedding到向量中，得到单词的词向量
x
i
t
x_{it}
xit（具体公式是上面第一个。）
然后通过双向GRU，可以将正向和反向的上下文信息结合起来获得隐藏层的输出。（具体公式是上面第2-4个）
第i个句子第t个词的输出为：
u
i
t
=
tanh
(
W
w
h
i
t
+
b
w
)
u_{it}=\text{tanh}(W_wh_{it}+b_w)
uit=tanh(Wwhit+bw)
α
i
t
=
exp
(
u
i
t
⊤
u
w
)
∑
t
exp
(
u
i
t
⊤
u
w
)
)
\alpha_{it}=\frac{\text{exp}(u_{it}^{\top}u_w)}{\sum_t\text{exp}(u_{it}^{\top}u_w))}
αit=∑texp(uit⊤uw))exp(uit⊤uw)
s
i
=
∑
t
α
i
t
h
i
t
s_i=\sum_t\alpha_{it}h_{it}
si=t∑αithit
u
i
t
u_{it}
uit：隐层表示，对应的是上图中中间绿色正方形框框
α
i
t
\alpha_{it}
αit：注意力分数（权重），用随机初始化（在训练过程中也是不断更新的）的
u
w
u_w
uw和隐层表示
u
i
t
u_{it}
uit求相似度后进行softmax分类得到该权重。这里的
u
w
u_w
uw是作者自己创建的注意力机制中的Query（随机初始化，并在梯度下降中进行优化），然后
u
i
t
u_{it}
uit是Key，代表第i句话的所有词的集合。
s
i
s_i
si：句子向量表示
不是所有的词对句子表示都很重要，因此使用注意力机制来实现提取词语对句子含义重要程度的信息，并将该信息汇总形成句子向量。
s
i
s_i
si：句子向量
h
i
h_i
hi：隐层向量
h
i
→
=
G
R
U
→
(
s
i
)
,
i
∈
[
1
,
L
]
\overrightarrow{h_{i}}=\overrightarrow{GRU}(s_{i}),i\in[1,L]
hi
=GRU
(si),i∈[1,L]
h
i
←
=
G
R
U
←
(
s
i
)
,
i
∈
[
1
,
L
]
\overleftarrow{h_{i}}=\overleftarrow{GRU}(s_{i}),i\in[1,L]
hi
=GRU
(si),i∈[1,L]
h
i
=
[
h
i
→
,
h
i
←
]
h_{i}=[\overrightarrow{h_{i}},\overleftarrow{h_{i}}]
hi=[hi
,hi
]
由句子向量到文档向量和上面的流程一样
u
i
=
t
a
n
h
(
W
s
h
i
+
b
s
)
u_{i}=tanh(W_sh_{i}+b_s)
ui=tanh(Wshi+bs)
α
i
=
e
x
p
(
u
i
⊤
u
s
)
∑
t
e
x
p
(
u
i
⊤
u
s
)
)
\alpha_{i}=\frac{exp(u_{i}^{\top}u_s)}{\sum_texp(u_{i}^{\top}u_s))}
αi=∑texp(ui⊤us))exp(ui⊤us)
v
=
∑
i
α
i
h
i
v=\sum_i\alpha_{i}h_{i}
v=i∑αihi
u
i
u_{i}
ui：隐层表示
α
i
t
\alpha_{it}
αit：注意力分数（权重），
v
v
v：文档向量
·文档向量v是文档的高级表示，可用作文档分类的功能：
p
=
s
o
f
t
m
a
x
(
W
c
v
+
b
c
)
p=softmax(W_cv+b_c)
p=softmax(Wcv+bc)
·损失函数：负对数似然
L
=
−
∑
d
l
o
g
p
d
j
L=-\sum_dlogp_{dj}
L=−d∑logpdj
介绍论文中模型的实验设置和运行结果
论文中使用了六个数据集，Yelp reviews2013，2014，2015；IMDB reviews；Yahoo Answers；Amazon reviews
每个数据集合中80%的数据用作训练集合，10%的数据用作验证集合，剩余10%的集合用作测试集合
实验任务：六个数据集上的文本分类
对比模型：
·线性模型
·SVM
·word-based CNN（基于词的CNN）
·Character-based CNN（基于字符集的CNN Character-level Convolutional Networks for Text Classification）
·ConV/LSTM-GRNN：Document Modeling with Gated Recurrent Neural Network for Sentiment Classification
·HN-AVE使用平均来处理向量融合。
·HN-MAX使用求最大值处理向量融合。
·HN-ATT使用注意力机制处理向量融合。
·在各个数据集上均取得最优的结果。
模型参数：批次大小：64；动量值：0.9
无论数据集大小，结果都是最好。
单词“good”的权重分布情况，a是总体情况，b-f是good这个单词在好评度从差评过度到好评（1,2，3,4，5分）的不同分类中权重变化的情况，在f中很明显，good在好评中的权重很大。
单词“bad”的权重分布情况
注意力机制可视化分析，红色是句子注意力，蓝色是词注意力。这里每句话进行了处理，句子不重要就不显示该句话中的重要的词。
A）提出一种用于文本分类的层次注意力网络
B）该网路首先构建句子的表示然后将它们聚合成文档表示
C）该网络在单词和句子级别应用了两个级别的注意机制
关键点
·之前的基于深度学习的文本分类没有关注到文档不同部分的信息重要性的不同。
·通过注意力机制可以学习到文档中各个部分对于分类的重要度。
·HAN Attention模型。
创新点
·提出了一种新的文本分类模型—HAN Attention模型
·HAN Attention模型通过两种级别的注意力机制同时学习文档中重要的句子和单词。
·在六个文本分类数据集上取得sota的结果。
启发点
·我们模型背后的直觉是文档不同部分对于问题的重要性不同，而且这些部分的重要性还取决于内部的
单词，而不仅仅是对这部分单独确定重要性。
The intuition underlying our model is that not all parts of a document are equally relevant for answering a query and that determining the relevant sections involves modeling the interactions of the words，not just their presence in isolation（Introduction P2）
·此外，单词和句子的重要性是上下文相关的，同样的词或者句子在不同的上下文情景下重要性也不同。
Moreover，the importance of words and sentences are highly context dependent，i.e.the same word or sentence may be differentially important in different context.（Introduction P3）
Tianyang Zhang et al.2018.Learning Structured Representation for Text Classification via Reinforcement Learning （清华团队出品）
Joulin et al.2017.Bag of Tricks for Efficient Text Classification （这个有带读笔记）
Johnson et al.2017.Deep Pyramid Convolutional Neural Networks for Text Categorization （DPCNN用于捕捉全局语义表示）
JacobDevlin et al.2019.BERT:Pre-training of Deep Bidirectional Transformers for Language Understanding（BERT）
代码结构：
数据集下载
数据集: http://ir.hit.edu.cn/~dytang/paper/emnlp2015/emnlp-2015-data.7z
其他数据集可以看之前baseline里面有。
本次用的是影评数据imdb，前面两列估计是编号和外键，数字是类别，后面是评论。
层次文档分类的数据处理
# coding:utf-8
from torch.utils import data
import os
import torch
import nltk
import numpy as np
from gensim.models import KeyedVectors
import nltk
# 数据集加载
# 根据长度排序，这个之前讲过，按长度进行排序后，句子长度相近，就可以使得pad的效率比较高
# 创建word2id
# 分句
# 将数据转化成id
class IMDB_Data(data.DataLoader):
def __init__(self, data_name, min_count, word2id=None, max_sentence_length=100, batch_size=64, is_pretrain=False):
self.path = os.path.abspath(".")
if "data" not in self.path:
self.path += "/data"
self.data_name = "/imdb/" + data_name
self.min_count = min_count
self.word2id = word2id
self.max_sentence_length = max_sentence_length
self.batch_size = batch_size
self.datas, self.labels = self.load_data()
if is_pretrain:
self.get_word2vec()
else:
self.weight = None
for i in range(len(self.datas)):
self.datas[i] = np.array(self.datas[i])
def load_data(self):
datas = open(self.path + self.data_name, encoding="utf-8").read().splitlines()
# -1代表最后一个字段就是文章列，2是label列，把两个东西放在一起，按句子长度排序，这样不会丢失句子和label的对应关系。
datas = [data.split(" ")[-1].split() + [data.split(" ")[2]] for data in datas]
# 按句子长度排序reverse=True代表从大到小，这样可以防止显存分配不足
datas = sorted(datas, key=lambda x: len(x), reverse=True)
# 获取label
labels = [int(data[-1]) - 1 for data in datas]
# 剥离label
datas = [data[0:-1] for data in datas]
if self.word2id == None:
self.get_word2id(datas)
# 分句
for i, data in enumerate(datas):
#数据集中是用<sssss>来进行分句的
datas[i] = " ".join(data).split("<sssss>")
for j, sentence in enumerate(datas[i]):
datas[i][j] = sentence.split()
datas = self.convert_data2id(datas)
return datas, labels
def get_word2id(self, datas):
word_freq = {}
for data in datas:
for word in data:
word_freq[word] = word_freq.get(word, 0) + 1
word2id = {"<pad>": 0, "<unk>": 1}
for word in word_freq:
# 小于min_count设置为UNK词
if word_freq[word] < self.min_count:
continue
else:
word2id[word] = len(word2id)
self.word2id = word2id
# max_sentence_length 句子必须是一样长。
# batch_size 代表每个batch_size，每个文档的句子一样多。
def convert_data2id(self, datas):
for i, document in enumerate(datas):
if i % 10000 == 0:
print(i, len(datas))
for j, sentence in enumerate(document):
for k, word in enumerate(sentence):
datas[i][j][k] = self.word2id.get(word, self.word2id["<unk>"])
# 超长截断，过短pad补齐
datas[i][j] = datas[i][j][0:self.max_sentence_length] + \
[self.word2id["<pad>"]] * (self.max_sentence_length - len(datas[i][j]))
for i in range(0, len(datas), self.batch_size):
max_data_length = max([len(x) for x in datas[i:i + self.batch_size]])
for j in range(i, min(i + self.batch_size, len(datas))):
datas[j] = datas[j] + [[self.word2id["<pad>"]] * self.max_sentence_length] * (
max_data_length - len(datas[j]))
datas[j] = datas[j]
return datas
def get_word2vec(self):
'''
生成word2vec词向量
:return: 根据词表生成的词向量
'''
print("Reading word2vec Embedding...")
wvmodel = KeyedVectors.load_word2vec_format(self.path + "/imdb.model", binary=True)
tmp = []
for word, index in self.word2id.items():
try:
tmp.append(wvmodel.get_vector(word))
except:
pass
mean = np.mean(np.array(tmp))
std = np.std(np.array(tmp))
print(mean, std)
vocab_size = len(self.word2id)
embed_size = 200
np.random.seed(2)
embedding_weights = np.random.normal(mean, std, [vocab_size, embed_size]) # 正太分布初始化方法
for word, index in self.word2id.items():
try:
embedding_weights[index, :] = wvmodel.get_vector(word)
except:
pass
self.weight = torch.from_numpy(embedding_weights).float()
def __getitem__(self, idx):
return self.datas[idx], self.labels[idx]
def __len__(self):
return len(self.labels)
if __name__ == "__main__":
imdb_data = IMDB_Data(data_name="imdb-train.txt.ss", min_count=5, is_pretrain=True)
training_iter = torch.utils.data.DataLoader(dataset=imdb_data,
batch_size=64,
shuffle=False,
num_workers=0)
for data, label in training_iter:
print(np.array(data).shape)
基于Pytorch的文本分类注意力机制实现以及HAN Attention模型实现
# -*- coding: utf-8 -*-
import torch
import torch.nn as nn
import numpy as np
from torch.nn import functional as F
from torch.autograd import Variable
class HAN_Model(nn.Module):
def __init__(self, vocab_size, embedding_size, gru_size, class_num, is_pretrain=False, weights=None):
super(HAN_Model, self).__init__()
# 判断是否词向量是否预训练，不是预训练效果会差一点
if is_pretrain:
self.embedding = nn.Embedding.from_pretrained(weights, freeze=False)
else:
self.embedding = nn.Embedding(vocab_size, embedding_size)
# 词的双向gru
self.word_gru = nn.GRU(input_size=embedding_size, hidden_size=gru_size, num_layers=1,
bidirectional=True, batch_first=True)
# 词attention的Query
self.word_context = nn.Parameter(torch.Tensor(2 * gru_size, 1), requires_grad=True)
self.word_dense = nn.Linear(2 * gru_size, 2 * gru_size)
# 句子的双向gru，这里的输入shape是上一句的输出2*gru_size,
self.sentence_gru = nn.GRU(input_size=2 * gru_size, hidden_size=gru_size, num_layers=1,
bidirectional=True, batch_first=True)
# 句attention的Query
self.sentence_context = nn.Parameter(torch.Tensor(2 * gru_size, 1), requires_grad=True)
self.sentence_dense = nn.Linear(2 * gru_size, 2 * gru_size)
# class_num是最后文本分类的类别数量
self.fc = nn.Linear(2 * gru_size, class_num)
def forward(self, x, gpu=False):
# 句子个数
sentence_num = x.shape[1]
# 句子长度
sentence_length = x.shape[2]
# x原来维度是bs*sentence_num*sentence_length，经过下面变化成二维的：(bs*sentence_num)*sentence_length
x = x.view([-1, sentence_length])
# 加了embedding维度：(bs*sentence_num)*sentence_length*embedding_size
x_embedding = self.embedding(x)
# word_outputs.shape:(bs*sentence_num)*sentence_length*(2*gru_size)，这里因为是双向gru所以是2*gru_size
word_outputs, word_hidden = self.word_gru(x_embedding)
# attention_word_outputs.shape:(bs*sentence_num)*sentence_length*(2*gru_size)，这里对应原文公式5
attention_word_outputs = torch.tanh(self.word_dense(word_outputs))
# weights.shape:(bs*sentence_num)*sentence_length*1，，这里和下面一句对应原文公式6
weights = torch.matmul(attention_word_outputs, self.word_context)
# weights.shape: (bs * sentence_num) * sentence_length * 1
weights = F.softmax(weights, dim=1)
# 这里对x加一个维度：(bs*sentence_num)*sentence_length*1
x = x.unsqueeze(2)
# 对x加的这个维度进行判断，如果这个维度上为0，表示这个地方是pad出来的，没有必要进行计算。
# 如果为1，则按weight进行计算比例
if gpu:
weights = torch.where(x != 0, weights, torch.full_like(x, 0, dtype=torch.float).cuda())
else:
weights = torch.where(x != 0, weights, torch.full_like(x, 0, dtype=torch.float))
# 这里由于忽略掉了pad为0的部分，所以要按维度重新计算分布
weights = weights / (torch.sum(weights, dim=1).unsqueeze(1) + 1e-4)
# bs*sentence_num*(2*gru_size)
sentence_vector = torch.sum(word_outputs * weights, dim=1).view([-1, sentence_num, word_outputs.shape[-1]])
# sentence_outputs.shape:bs*sentence_num*(2*gru_size)
sentence_outputs, sentence_hidden = self.sentence_gru(sentence_vector)
# 对应原文公式8：bs*sentence_num*(2*gru_size)
attention_sentence_outputs = torch.tanh(self.sentence_dense(sentence_outputs))
# bs*sentence_num*1
weights = torch.matmul(attention_sentence_outputs, self.sentence_context)
# bs*sentence_num*1
weights = F.softmax(weights, dim=1)
# bs * sentence_num * sentence_length
x = x.view(-1, sentence_num, x.shape[1])
# bs * sentence_num * 1
x = torch.sum(x, dim=2).unsqueeze(2)
if gpu:
# bs * sentence_num * 1
weights = torch.where(x != 0, weights, torch.full_like(x, 0, dtype=torch.float).cuda())
else:
weights = torch.where(x != 0, weights, torch.full_like(x, 0, dtype=torch.float))
# bs * sentence_num * 1，对未计算的pad进行缩放
weights = weights / (torch.sum(weights, dim=1).unsqueeze(1) + 1e-4)
# bs *(2*gru)
document_vector = torch.sum(sentence_outputs * weights, dim=1)
# bs * class_num
output = self.fc(document_vector)
return output
if __name__ == "__main__":
han_model = HAN_Model(vocab_size=30000, embedding_size=200, gru_size=50, class_num=4)
x = torch.Tensor(np.zeros([64, 50, 100])).long()
x[0][0][0:10] = 1
output = han_model(x)
print(output.shape)
基于Pytorch的HAN Attention模型的训练和测试
# -*- coding: utf-8 -*-
import torch
import torch.autograd as autograd
import torch.nn as nn
import torch.optim as optim
from model import HAN_Model
from data import IMDB_Data
import numpy as np
from tqdm import tqdm
import config as argumentparser
config = argumentparser.ArgumentParser()
torch.manual_seed(config.seed)
if config.cuda and torch.cuda.is_available():
torch.cuda.set_device(config.gpu)
def get_test_result(data_iter, data_set):
# 生成测试结果
model.eval()
true_sample_num = 0
for data, label in data_iter:
if config.cuda and torch.cuda.is_available():
data = data.cuda()
label = label.cuda()
else:
data = torch.autograd.Variable(data).long()
if config.cuda and torch.cuda.is_available():
out = model(data, gpu=True)
else:
out = model(data)
true_sample_num += np.sum((torch.argmax(out, 1) == label).cpu().numpy())
acc = true_sample_num / data_set.__len__()
return acc
# 导入训练集，shuffle=False，不能是true，因为是按句子长度排序的
training_set = IMDB_Data("imdb-train.txt.ss", min_count=config.min_count,
max_sentence_length=config.max_sentence_length, batch_size=config.batch_size, is_pretrain=True)
training_iter = torch.utils.data.DataLoader(dataset=training_set,
batch_size=config.batch_size,
shuffle=False,
num_workers=0)
test_set = IMDB_Data("imdb-test.txt.ss", min_count=config.min_count, word2id=training_set.word2id,
max_sentence_length=config.max_sentence_length, batch_size=config.batch_size)
test_iter = torch.utils.data.DataLoader(dataset=test_set,
batch_size=config.batch_size,
shuffle=False,
num_workers=0)
if config.cuda and torch.cuda.is_available():
training_set.weight = training_set.weight.cuda()
model = HAN_Model(vocab_size=len(training_set.word2id),
embedding_size=config.embedding_size,
gru_size=config.gru_size, class_num=config.class_num, weights=training_set.weight, is_pretrain=True)
if config.cuda and torch.cuda.is_available():
model.cuda()
# CrossEntropyLoss自带softmax效果，无需额外做softmax
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=config.learning_rate)
loss = -1
for epoch in range(config.epoch):
model.train()
process_bar = tqdm(training_iter)
for data, label in process_bar:
if config.cuda and torch.cuda.is_available():
data = data.cuda()
label = label.cuda()
else:
data = torch.autograd.Variable(data).long()
label = torch.autograd.Variable(label).squeeze()
if config.cuda and torch.cuda.is_available():
out = model(data, gpu=True)
else:
out = model(data)
loss_now = criterion(out, autograd.Variable(label.long()))
if loss == -1:
loss = loss_now.data.item()
else:
loss = 0.95 * loss + 0.05 * loss_now.data.item()# 平滑处理
process_bar.set_postfix(loss=loss_now.data.item())
process_bar.update()
optimizer.zero_grad()
loss_now.backward()
optimizer.step()
test_acc = get_test_result(test_iter, test_set)
print("The test acc is: %.5f" % test_acc)
总结HAN Attention模型以及实现
