最近在看一个比赛：2019 搜狐校园算法大赛，赛题说的是

给定若干文章，目标是判断文章的核心实体以及对核心实体的情感态度。每篇文章识别最多三个核心实体，并分别判断文章对上述核心实体的情感倾向（积极、中立、消极三种）。

这里说的是实体识别，马上想到的就是利用分步走解决：先去对文章进行实体识别，然后对提取出来的实体进行情感分类。但是后来一想这样两步的话会使得最终结果的错误率叠加，也就是说第一步做的不好的话会很大程度影响到第二步的结果。其实仔细看一下数据集会发现，它给出的很多样本实体并不是传统实体识别的实体，而是句子中的某一个token。这就跟SemEval2014的subtask 4非常像了，也就是Aspect Based Sentiment Analysis (ABSA)。不说废话了，接下来我们来看看关于ABSA问题都有哪些常用的算法。

1. A glance at ABSA（什么是ABSA）

在介绍具体算法之前，先来看一下什么是ABSA？可以粗暴翻译为基于方面的情感分析，本质就是对句子中不同对象可能会存在不同的情感倾向，例如：“I bought a new camera. The picture quality is amazing but the battery life is too short”，这句话中对于target=picture quality，情感是正的；而对于target=battery，情感就是负的了。ABSA任务的目的就是去找出给定句子中的不同target的情感倾向。

一个关于ABSA的PPT介绍

---

2. Effective LSTMs for Target-Dependent Sentiment Classification（Tang/COLING2016）

在这篇论文里面作者主要是介绍了三种解决ABSA任务的模型：

• LSTM
• Target-Dependent LSTM (TD-LSTM)
• Target-Connection LSTM (TC-LSTM)

LSTM

第一种方法就是直接使用NLP中的万金油模型LSTM，在该模型中，target words是被忽略的，也就是说跟普通的对文本情感分析的做法没有区别，最终得到的也是这个句子的全局情感，可想而知最后的效果一般般。具体做法就是对句子中的token进行embedding处理作为模型的输入，经过一次一次的计算隐层和输入之后得到一个句子表示$h_n$，接着对这个向量进行softmax计算概率， 其中C是情感类别种类。
$${\mathrm{softmax}}_i=\frac{\exp \left(x_i\right)}{{\sum }_{i^{\prime }=1}^C\exp \left(x_{i^{\prime }}\right)}$$

TD-LSTM

为了解决上面LSTM忽略目标词的问题，提出了TD-LSTM模型，如下图所示。

其基本思想是对于一个target-word，充分考虑其上下文信息，具体来说使用了两个LSTM，从左往右的和从右往左的，分别对target word的左边和右边的信息建模。接着将两个LSTM得到的隐状态$h_l$和$h_r$ concat一下，也就得到了关于这个词的句子情感表示，然后一样也是送入到softmax进行分类。除了concat作者也提到可以尝试进行sum或者average。

TC-LSTM

TC-LSTM在TD-LSTM的基础上进一步加强了target-word与句子中每个token的关联，看模型框架就会很清晰，

可以看出，这里在模型输入的时候多加入了一部分：$v_{target}$，这样就可以加强target与句子的交互，使得最后的表示更为确切。那么这个$v_{target}$是怎么得到的呢？其实就是简单地对target words的向量表示进行平均化处理得到一个向量。

实验结果比对

---

3. Attention-based LSTM for Aspect-level Sentiment Classification（Wang/EMNLP2016）

这是在Effective LSTMs for Target-Dependent Sentiment Classification后面发出的文章，指出前者的不足之处：

However, those models can only take into consideration the target but not aspect information which is proved to be crucial for aspect-level classification.

作者这里提到了两个概念：target和aspect。我们可以认为target是包含在句子中出现的词，而aspect属于预先定义的比较high-level的类别刻画。
基于以上，提出了两种模型：

• Attention-based LSTM (AT-LSTM)
• Attention-based LSTM with Aspect Embedding (ATAE-LSTM)

Aspect Embedding

对于ABSA问题，aspect信息对于最终的情感判别是非常重要的。因此作者对每个aspect都学习一个相应地aspect embedding来表示， $v_{a_i}$

AT-LSTM

既然学习出了aspect embedding，那么怎么把它结合进模型里呢？这里使用的是超级火的注意力机制，如下图所示

为了更好地理解上述模型，首先回顾一下 vanilla attention mechanism，也就是key-value-query模型，具体可以参考理解Attention机制原理及模型。这里可以认为key=H, value=H, query=aspect embedding，整个attention的过程可以用数学表示为：

$$\begin{array}{l}M=\tanh \left(\left[\begin{array}{c}{W}_{h}H\\ W_v{v}_a\otimes e_N\end{array}\right]\right)\\ \alpha =\mathrm{softmax}\left(w^{T}M\right)\\ r=H{\alpha }^T\end{array}$$
其中r表示各hidden state带权重后的表示，然后最终句子的表示为：
$$h^{\ast }=\tanh \left(W_{p}r+W_x{h}_N\right)$$
得到句子的表示后再进行情感判别：
$$y=\mathrm{softmax}\left(W_s{h}^{\ast }+b_s\right)$$

ATAE-LSTM

为了进一步利用aspect embedding的信息，类似于上一节中TC-LSTM中的思想，即将aspect embedding与word embedding共同组合成模型的输入。模型的其他部分与AT-LSTM相同。

注意力结果可视化

试验分析

论文使用的数据集是SemEval 2014 Task 4，正如开篇提到的一样。

---

4. Learning to Attend via Word-Aspect Associative Fusion for Aspect-based Sentiment Analysis（Tay/AAAI2018）

对于上一节的ATAE-LSTM，作者认为仍然存在以下不足：

• ATAE中的attention层学习上下文词之间的重要性关系，而不是对aspect和context之间建模。（？？？没懂，上下文词之间的重要性关系不就是相对于aspect而言的吗，就是上下文词与aspect之间的重要程度关系吧…）
• 简单的aspect embedding和word embedding拼接使得模型难以训练

针对以上提出了Aspect Fusion LSTM (AF-LSTM)，模型整体框架如下：

Word-Aspect Fusion Attention Layer

在输入经过embedding层和LSTM层之后进入到Word-Aspect Fusion Attention Layer，这也是该模型的重点。

1. Normalization Layer（optional）： 在隐状态矩阵和aspect vector进行交互之前可以选择性地对其进行正规化操作，可以选用Batch Normalization；
2. Associative Memory Operators： 用于计算context word 和 aspect word之间的关系。有两种：
   • circular correlation和circular convolution
     
     $$[h\star s{]}_k=\sum _{i=0}^{d-1}{h}_i{s}_{(k+i)}\mathrm{m}\mathrm{o}\mathrm{d}d$$
     也可以用傅里叶变化得到:$$h\star a={\mathcal{F}}^{-1}(\overline{\mathcal{F}(h)}\odot \mathcal{F}(a))$$
   • circular convolution
     
     $$[h\ast s{]}_k=\sum _{i=0}^{d-1}{h}_i{s}_{(k-i)\mathrm{m}\mathrm{o}\mathrm{d}d}$$
3. Learning Attentive Representations: 将aspect和context进行fusion之后得到的向量表示进行attention操作

试验分析

5. Interactive Attention Networks for Aspect-Level Sentiment Classification（Ma/IJCAI2017）

这篇文章作者的思路也是将target和context进行交互获取句子的准确表达，利用的模型是attention。与上面几个模型不同的在于，这里考虑了target可能存在好几个word组成的短语，另外添加了一层对于target的attention操作用于计算权重。提出了Interactive Attention Networks(IAN)， 整体模型框架如下：

IAN

1. 输入包括n个单词的context：$\left[w_c^1,w_c^2,\dots ,w_c^n\right]$和m个单词的target ：$\left[w_t^1,w_t^2,\dots ,w_t^m\right]$
2. 对输入进行embedding层后输入到LSTM网络中得到各个隐状态表示；
3. 对所有隐状态求平均分别得到target和context的隐状态表示，以此作为后续attention两者的交互：
   $$c_{avg}=\sum _{i=1}^n{h}_c^i/n$$ $$t_{avg}=\sum _{i=1}^m{h}_t^i/m$$
4. 分别计算attention权重得分：
   $$\gamma \left(h_c^i,t_{avg}\right)=\tanh \left(h_c^i\cdot W_a\cdot t_{avg}^T+b_a\right)$$$${\alpha }_i=\frac{\exp \left(\gamma \left(h_c^i,t_{avg}\right)\right)}{{\sum }_{j=1}^n\exp \left(\gamma \left(h_c^j,t_{avg}\right)\right)}$$
   $$\gamma \left(h_t^i,c_{avg}\right)=\tanh \left(h_t^i\cdot W_{a^{\prime }}\cdot c_{avg}^T+b_{a^{\prime }}\right)$$$${\beta }_i=\frac{\exp \left(\gamma \left(h_t^i,c_{avg}\right)\right)}{{\sum }_{j=1}^m\exp \left(\gamma \left(h_t^j,c_{avg}\right)\right)}$$
5. 根据单词权重计算target和context的最终表示：
   $$\begin{array}{rl}{c}_r& =\sum _{i=1}^n{\alpha }_i{h}_c^i\\ t_r& =\sum _{i=1}^m{\beta }_i{h}_t^i\end{array}$$
6. 将$c_r$和$t_r$拼接起来作为整个输入句子的向量表示，并送入softmax计算类别概率

试验分析

同样数据集选用的也是SemEval 2014 Task 4，

---

以上~
2019.05.03

高级实训任务三:文本情感分类

1.任务描述

● 将循环任务（RNN）应用在图像分割任务上，我们需要对网络结构进行设计。
● 需要提交博客报告以及GitHub代码仓库。
● 可选的任务：文本情感分类（正向、负向）。
● 可选的网络结构：GRU、LSTM。
● 可选的数据集：
○ imdb数据集：https://www.kaggle.com/c/sentiment-analysis-on-movie-reviews
○ 烂番茄数据集：https://www.kaggle.com/c/sentiment-analysis-on-movie-reviews/overview
● 可选深度学习框架：Tensorflow、PyTorch、Keras。
● 完成期限：1月21日
● 提交结果：项目报告、答辩幻灯片、相关代码和测试用例。

2.任务选择

将循环任务(RNN)应用在图像分割上，需要对网络结构进行设计。
任务选择：文本情感分类（正向，负向）
选择的网络结构：LSTM
语言：python
框架选择：pytorch（主框架，构建网络结构）
其他辅助框架：pickle（python 的文件库。由于数据集的一部分放在pkl文件里，需要pickle库进行读取）
tqdm （UI方面的库，用于添加进度条，方便观察计算的进度）
数据集：aclImdb（大型电影评论数据集）

3.任务开始准备

• 循环任务（RNN）应用在图像分割任务原理
  循环神经网络的应用场景比较多，比如暂时能写论文，写程序，写诗，但是，（总是会有但是的），但是他们现在还不能正常使用，学习出来的东西没有逻辑，所以要想真正让它更有用，路还很远。
  一般的神经网络应该有的结构：
  

• 使用循环神经网络原因：
  无论是卷积神经网络，还是人工神经网络，他们的前提假设都是：元素之间是相互独立的，输入与输出也是独立的，比如猫和狗。但现实世界中，很多元素都是相互连接的，比如股票随时间的变化，我们是根据上下文的内容推断出来的，但机会要做到这一步就相当得难了。因此，就有了现在的循环神经网络，他的本质是：像人一样拥有记忆的能力。因此，他的输出就依赖于当前的输入和记忆。

• RNN的网络结构及原理
  
  其中每个圆圈可以看作是一个单元，而且每个单元做的事情也是一样的，因此可以折叠呈左半图的样子。用一句话解释RNN，就是一个单元结构重复使用。

• LSTM原理
  1.LSTM内部结构：
  

LSTM看上去就是这样一种效果，一个一个首尾相接，同一层的会把前面单元的输出作为后面单元的输入；前一层的输出会作为后一层的输入。细胞状态

2.LSTM 的关键就是细胞状态，水平线在图上方从左到右贯穿运行。

细胞状态类似于传送带。直接在整个链上运行，只有一些少量的线性交互。信息在上面流传保持不变会很容易

左面的乘号是一个乘法操作，右面的加号就是普通的线性叠加。
LSTM规避了标准RNN中梯度爆炸和梯度消失的问题，所以会显得更好用，学习速度更快

下图是最基本的LSTM单元连接起来的样子

3.LSTM的门结构
**遗忘门：**遗忘门层决定我们会从细胞状态中丢弃什么信息。该门会读取ht−1 和xt ，输出一个在 0到 1之间的数值给每个在细胞状态 Ct−1 中的数字。1 表示“完全保留”，0 表示“完全舍弃”。
[ht−1​,xt]代表把两个向量连接起来。

更新门：C t 表示新的输入带来的信息，tanh这个激活函数讲内容归一化到-1到1;
it用于选择保留新信息的哪个部分。ft * Ct-1表示过去信息有选择的遗忘（保留），
Ct 表示新信息有选择的遗忘（保留），两者相加得到新状态Ct。

输出门：

4.实验过程和结果

代码：
1.读取imdb数据集：

max_f=10000
(x_train, y_train),(x_test,y_test) = imdb_data(num_words = max_f)

maxlength = 400
x_train = sequence.pad_sequences(x_train,maxlength = maxlength)
x_test = sequence.pad_sequences(x_test,maxlength = maxlength

2.构建LSTM训练模型

model = Sequential([layers.Embedding(max_f,32),
					layers.LSTM(32),
					layers.Dense(1,activation="sigmoid")
					])
model.compile(optimizer="rmsprop",loss='binary_crossentropy',metrics=["accuracy"])

history = model.fita(x_train , y_train, epochs=10,batch_size = 128,
					validation_data = (x_train , y_train),callbacks=callbacks_list)

3.实验结果：

Epoch 1/10  25000/25000 [==============================] - 313s 12ms/sample - loss: 0.4751 - acc: 0.7779 - val_loss: 0.6679 - val_acc: 0.7521
Epoch 2/10  25000/25000 [==============================] - 265s 11ms/sample - loss: 0.2848 - acc: 0.8869 - val_loss: 0.2021 - val_acc: 0.9271
Epoch 3/10  25000/25000 [==============================] - 251s 11ms/sample - loss: 0.2362 - acc: 0.9128 - val_loss: 0.2687 - val_acc: 0.8936
Epoch 4/10  25000/25000 [==============================] - 172s 7ms/sample - loss: 0.2011 - acc: 0.9239 - val_loss: 0.2430 - val_acc: 0.9182
Epoch 5/10  25000/25000 [==============================] - 145s 6ms/sample - loss: 0.1855 - acc: 0.9311 - val_loss: 0.1540 - val_acc: 0.9434
Epoch 6/10  25000/25000 [==============================] - 148s 6ms/sample - loss: 0.1686 - acc: 0.9394 - val_loss: 0.1093 - val_acc: 0.9639
Epoch 7/10  25000/25000 [==============================] - 143s 6ms/sample - loss: 0.1542 - acc: 0.9439 - val_loss: 0.1670 - val_acc: 0.9368
Epoch 8/10  25000/25000 [==============================] - 145s 6ms/sample - loss: 0.1438 - acc: 0.9491 - val_loss: 0.1907 - val_acc: 0.9227
Epoch 9/10  25000/25000 [==============================] - 147s 6ms/sample - loss: 0.1351 - acc: 0.9524 - val_loss: 0.1359 - val_acc: 0.9539
Epoch 10/10  25000/25000 [==============================] - 143s 6ms/sample - loss: 0.1293 - acc: 0.9561 - val_loss: 0.1029 - val_acc: 0.9655

实验结论：可以看到经过10轮训练后，训练集准确度为0.9561，测试集准确度为0.9655，训练过程中测试集准确度最高为0.9655。可以看出随着周期数的增多，准确度也在不断增高。

总结

LSTM和其他神经网络用途类似，主要用于分类或预测。能够改善了RNN中存在的长期依赖问题；LSTM的表现通常比时间递归神经网络及隐马尔科夫模型（HMM）更好；作为非线性模型，LSTM可作为复杂的非线性单元用于构造更大型深度神经网络。

1 常见NLP文本分类模型

1.1 TextCNN

        论文原文：《Convolutional Neural Networks for Sentence Classification》

        论文地址：1408.5882.pdf (arxiv.org)

        结构图如下：

          值得一提的是，在2016年的《A Sensitivity Analysis of (and Practitioners’ Guide to) Convolutional Neural Networks for Sentence Classification》作者通过大量实验对TextCNN进行网络参数选取，并给出了参数建议。论文地址：https://arxiv.org/pdf/1510.03820.pdf，文章经典的结构图如下：

 

 1.2 TextRNN

        TextRNN指的是利用RNN循环神经网络解决文本分类问题。

        论文原文：《Recurrent Neural Network for Text Classification with Multi-Task Learning》

        论文链接：https://www.ijcai.org/Proceedings/16/Papers/408.pdf

        结构图如下：

1.3 TextRCNN

        论文原文：《Recurrent Convolutional Neural Networks for Text Classification》

        论文链接：TextRCNN论文

        结构图如下：

1.4 FastText

        论文原文：《Bag of Tricks for Efficient Text Classification》

        论文链接：https://arxiv.org/pdf/1607.01759v2.pdf

        结构图如下：

1.5 HAN

        论文原文：《Hierarchical Attention Networks for Document Classification》

        论文链接：https://aclanthology.org/N16-1174.pdf

        结构图如下：

1.6 CharCNN

        论文原文：《Character-level Convolutional Networks for Text Classification》

        论文链接：CharCNN论文

        结构图如下：

1.7 Transformer

        论文原文：《Attention is all you need》

        论文链接：https://arxiv.org/pdf/1706.03762.pdf

        结构图如下：

2 代码实现

import torch
import torch.nn as nn
import torch.nn.functional as F

import numpy as np

import math
import copy

#TextCNN
class TextCNN(nn.Module):
    def __init__(self, args):
        super(TextCNN, self).__init__()
        self.args = args

        class_num = args.class_num
        chanel_num = 1
        filter_num = args.filter_num

        filter_sizes = args.filter_sizes

        vocabulary_size = args.vocabulary_size
        embedding_dimension = args.embedding_dim
        self.embedding = nn.Embedding(vocabulary_size, embedding_dimension)
        if args.static:
            self.embedding = self.embedding.from_pretrained(args.vectors, freeze=not args.non_static)
        if args.multichannel:
            self.embedding2 = nn.Embedding(vocabulary_size, embedding_dimension).from_pretrained(args.vectors)
            chanel_num += 1
        else:
            self.embedding2 = None
        self.convs = nn.ModuleList(
            [nn.Conv2d(chanel_num, filter_num, (size, embedding_dimension)) for size in filter_sizes])
        self.dropout = nn.Dropout(args.dropout)
        self.fc = nn.Linear(len(filter_sizes) * filter_num, class_num)

    def forward(self, x):
        if self.embedding2:
            x = torch.stack([self.embedding(x), self.embedding2(x)], dim=1)
        else:
            x = self.embedding(x)
            x = x.unsqueeze(1)
        x = [F.relu(conv(x)).squeeze(3) for conv in self.convs]
        x = [F.max_pool1d(item, int(item.size(2))).squeeze(2) for item in x]
        x = torch.cat(x, 1)
        x = self.dropout(x)
        logits = self.fc(x)
        return logits

#TextRNN
class LSTM(torch.nn.Module):
    def __init__(self, args):
        super(LSTM, self).__init__()
        self.embed_size = args.embedding_dim
        self.label_num = args.class_num
        self.embed_dropout = 0.1
        self.fc_dropout = 0.1
        self.hidden_num = 1
        self.hidden_size = 50
        self.hidden_dropout = 0
        self.bidirectional = True

        vocabulary_size = args.vocabulary_size
        embedding_dimension = args.embedding_dim

        self.embeddings = nn.Embedding(vocabulary_size, embedding_dimension)
        # self.embeddings.weight.data.copy_(torch.from_numpy(vocabulary_size))

        self.embeddings.weight.requires_grad = False

        self.lstm = nn.LSTM(
            self.embed_size,
            self.hidden_size,
            dropout=self.hidden_dropout,
            num_layers=self.hidden_num,
            batch_first=True,
            bidirectional=True
        )
        self.embed_dropout = nn.Dropout(self.embed_dropout)
        self.fc_dropout = nn.Dropout(self.fc_dropout)
        self.linear1 = nn.Linear(self.hidden_size * 2, self.label_num)
        self.softmax = nn.Softmax()

    def forward(self, input):
        x = self.embeddings(input)
        x = self.embed_dropout(x)
        batch_size = len(input)
        _, (lstm_out, _) = self.lstm(x)
        lstm_out = lstm_out.permute(1, 0, 2)
        lstm_out = lstm_out.contiguous().view(batch_size, -1)
        out = self.linear1(lstm_out)
        out = self.fc_dropout(out)
        out = self.softmax(out)
        return out

#TextRCNN
class BiLSTM(nn.Module):
    def __init__(self, args):
        super(BiLSTM, self).__init__()
        self.embed_size = args.embedding_dim
        self.label_num = args.class_num
        self.embed_dropout = 0.1
        self.fc_dropout = 0.1
        self.hidden_num = 2
        self.hidden_size = 50
        self.hidden_dropout = 0
        self.bidirectional = True

        vocabulary_size = args.vocabulary_size
        embedding_dimension = args.embedding_dim

        self.embeddings = nn.Embedding(vocabulary_size, embedding_dimension)
        # self.embeddings.weight.data.copy_(torch.from_numpy(word_embeddings))
        self.embeddings.weight.requires_grad = False
        self.lstm = nn.LSTM(
            self.embed_size,
            self.hidden_size,
            dropout=self.hidden_dropout,
            num_layers=self.hidden_num,
            batch_first=True,
            bidirectional=self.bidirectional
        )
        self.embed_dropout = nn.Dropout(self.embed_dropout)
        self.fc_dropout = nn.Dropout(self.fc_dropout)
        self.linear1 = nn.Linear(self.hidden_size * 2, self.hidden_size // 2)
        self.linear2 = nn.Linear(self.hidden_size // 2, self.label_num)

    def forward(self, input):
        out = self.embeddings(input)
        out = self.embed_dropout(out)
        out, _ = self.lstm(out)
        out = torch.transpose(out, 1, 2)
        out = torch.tanh(out)
        out = F.max_pool1d(out, out.size(2))
        out = out.squeeze(2)
        out = self.fc_dropout(out)
        out = self.linear1(F.relu(out))
        output = self.linear2(F.relu(out))
        return output

#FastText
class FastText(nn.Module):
    def __init__(self, args):
        super().__init__()
        self.output_dim = args.class_num
        vocabulary_size = args.vocabulary_size
        embedding_dimension = args.embedding_dim
        self.embeddings = nn.Embedding(vocabulary_size, embedding_dimension)
        self.fc = nn.Linear(embedding_dimension, self.output_dim)

    def forward(self, text):
        # text = [sent len, batch size]
        text = text.permute(1,0)
        embedded = self.embeddings(text)
        # embedded = [sent len, batch size, emb dim]
        embedded = embedded.permute(1, 0, 2)
        # embedded = [batch size, sent len, emb dim]
        pooled = F.avg_pool2d(embedded, (embedded.shape[1], 1)).squeeze(1)
        # pooled = [batch size, embedding_dim]
        return self.fc(pooled)

#HAN
class SelfAttention(nn.Module):
    def __init__(self, input_size, hidden_size):
        super(SelfAttention, self).__init__()
        self.W = nn.Linear(input_size, hidden_size, True)
        self.u = nn.Linear(hidden_size, 1)
    def forward(self, x):
        u = torch.tanh(self.W(x))
        a = F.softmax(self.u(u), dim=1)
        x = a.mul(x).sum(1)
        return x
class HAN(nn.Module):
    def __init__(self,args):
        super(HAN, self).__init__()

        hidden_size_gru = 50  # 50
        hidden_size_att = 100  # 100

        num_classes = args.class_num

        vocabulary_size = args.vocabulary_size
        embedding_dimension = args.embedding_dim

        self.num_words = 64 #词Pading大小

        self.embed = nn.Embedding(vocabulary_size, embedding_dimension)
        self.gru1 = nn.GRU(embedding_dimension, hidden_size_gru, bidirectional=True, batch_first=True)
        self.att1 = SelfAttention(hidden_size_gru * 2, hidden_size_att)
        self.gru2 = nn.GRU(hidden_size_att, hidden_size_gru, bidirectional=True, batch_first=True)
        self.att2 = SelfAttention(hidden_size_gru * 2, hidden_size_att)
        # 这里fc的参数很少，不需要dropout
        self.fc = nn.Linear(hidden_size_att, num_classes, True)

    def forward(self, x):
        # 64 512 200
        x = x.view(x.size(0) * self.num_words, -1).contiguous()
        x = self.embed(x)
        x, _ = self.gru1(x)
        x = self.att1(x)
        x = x.view(x.size(0) // self.num_words, self.num_words, -1).contiguous()
        x, _ = self.gru2(x)
        x = self.att2(x)
        x = self.fc(x)
        x = F.log_softmax(x, dim=1)  # softmax
        return x

#CharCNN
class CharCNN(nn.Module):
    def __init__(self, args):
        super(CharCNN, self).__init__()

        self.num_chars = 64
        self.features = [128, 128, 128, 128, 128, 128]
        self.kernel_sizes = [7, 7, 3, 3, 3, 3]
        self.dropout = args.dropout
        self.num_labels = args.class_num

        vocabulary_size = args.vocabulary_size
        embedding_dimension = args.embedding_dim

        # Embedding Layer
        self.embeddings = nn.Embedding(vocabulary_size, embedding_dimension)
        self.embeddings.weight.requires_grad = False

        self.in_features =  [self.num_chars]+self.features[:-1]
        self.out_features = self.features

        self.conv1d_1 = nn.Sequential(
            nn.Conv1d(self.in_features[0], self.out_features[0], self.kernel_sizes[0], stride=1),
            nn.BatchNorm1d(self.out_features[0]),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=3, stride=3)
        )
        self.conv1d_2 = nn.Sequential(
            nn.Conv1d(self.in_features[1], self.out_features[1], self.kernel_sizes[1], stride=1),
            nn.BatchNorm1d(self.out_features[1]),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=3, stride=3)
        )
        self.conv1d_3 = nn.Sequential(
            nn.Conv1d(self.in_features[2], self.out_features[2], self.kernel_sizes[2], stride=1),
            nn.BatchNorm1d(self.out_features[2]),
            nn.ReLU()
        )
        self.conv1d_4 = nn.Sequential(
            nn.Conv1d(self.in_features[3], self.out_features[3], self.kernel_sizes[3], stride=1),
            nn.BatchNorm1d(self.out_features[3]),
            nn.ReLU()
        )
        self.conv1d_5 = nn.Sequential(
            nn.Conv1d(self.in_features[4], self.out_features[4], self.kernel_sizes[4], stride=1),
            nn.BatchNorm1d(self.out_features[4]),
            nn.ReLU()
        )
        self.conv1d_6 = nn.Sequential(
            nn.Conv1d(self.in_features[5], self.out_features[5], self.kernel_sizes[5], stride=1),
            nn.BatchNorm1d(self.out_features[5]),
            nn.ReLU(),
            nn.MaxPool1d(kernel_size=3, stride=3)
        )

        self.fc1 = nn.Sequential(
            nn.Linear(128, 128),
            nn.ReLU(),
            nn.Dropout(self.dropout)
        )
        self.fc2 = nn.Sequential(
            nn.Linear(128, 128),
            nn.ReLU(),
            nn.Dropout(self.dropout)
        )
        self.fc3 = nn.Linear(128, self.num_labels)

    def forward(self, x):
        # x = torch.Tensor(x).long()   # batch_size=128, num_chars=128, seq_len=64
        x = self.embeddings(x)
        # x = x.permute(0,2,1)
        x = self.conv1d_1(x)  # b, out_features[0], （seq_len-f + 1）-f/s+1  = 64, 256, (1014-7+1)-3/3 + 1=1008-3/3+1=336
        x = self.conv1d_2(x)  # 64, 256, (336-7+1)-3/3+1=110
        x = self.conv1d_3(x)  # 64, 256, 110-3+1=108
        x = self.conv1d_4(x)  # 64, 256, 108-3+1=106
        x = self.conv1d_5(x)  # 64, 256, 106-3=1=104
        x = self.conv1d_6(x)  # 64, 256, (104-3+1)-3/3+1=34

        x = x.view(x.size(0), -1)  # 64, 256, 34 -> 64, 8704
        out = self.fc1(x)  # 64, 1024
        out = self.fc2(out)  # 64, 1024
        out = self.fc3(out)  # 64, 4
        return out

#Transformer
class Transformer_Config(object):
    """配置参数"""
    def __init__(self, args):
        # self.model_name = 'Transformer'
        # self.train_path = dataset + '/data/train.txt'                                # 训练集
        # self.dev_path = dataset + '/data/dev.txt'                                    # 验证集
        # self.test_path = dataset + '/data/test.txt'                                  # 测试集
        # self.class_list = [x.strip() for x in open(
        #     dataset + '/data/class.txt', encoding='utf-8').readlines()]              # 类别名单
        # self.vocab_path = dataset + '/data/vocab.pkl'                                # 词表
        # self.save_path = dataset + '/saved_dict/' + self.model_name + '.ckpt'        # 模型训练结果
        # self.log_path = dataset + '/log/' + self.model_name
        # self.embedding_pretrained = torch.tensor(
        #     np.load(dataset + '/data/' + embedding)["embeddings"].astype('float32'))\
        #     if embedding != 'random' else None                                       # 预训练词向量
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')   # 设备

        self.dropout = 0.5                                              # 随机失活
        self.require_improvement = 2000                                 # 若超过1000batch效果还没提升，则提前结束训练
        self.num_classes = args.class_num                         # 类别数
        self.n_vocab = args.vocabulary_size                                                # 词表大小，在运行时赋值
        self.num_epochs = args.epochs                                            # epoch数
        self.batch_size = args.batch_size                                           # mini-batch大小
        self.pad_size = 64                                              # 每句话处理成的长度(短填长切)
        self.learning_rate = 5e-4                                       # 学习率
        self.embedding_pretrained = None
        # self.embed = self.embedding_pretrained.size(1)\
        #     if self.embedding_pretrained is not None else 300           # 字向量维度
        self.embed = 128
        self.dim_model = args.embedding_dim
        self.hidden = 1024
        self.last_hidden = 512
        self.num_head = 2
        self.num_encoder = 2
'''Attention Is All You Need'''
class Transformer(nn.Module):
    def __init__(self, config):
        super(Transformer, self).__init__()
        if config.embedding_pretrained is not None:
            self.embedding = nn.Embedding.from_pretrained(config.embedding_pretrained, freeze=False)
        else:
            self.embedding = nn.Embedding(config.n_vocab, config.embed)

        self.postion_embedding = Positional_Encoding(config.embed, config.pad_size, config.dropout, config.device)
        self.encoder = Encoder(config.dim_model, config.num_head, config.hidden, config.dropout)
        self.encoders = nn.ModuleList([
            copy.deepcopy(self.encoder)
            # Encoder(config.dim_model, config.num_head, config.hidden, config.dropout)
            for _ in range(config.num_encoder)])

        self.fc1 = nn.Linear(config.pad_size * config.dim_model, config.num_classes)
        # self.fc2 = nn.Linear(config.last_hidden, config.num_classes)
        # self.fc1 = nn.Linear(config.dim_model, config.num_classes)

    def forward(self, x):
        out = self.embedding(x)
        out = self.postion_embedding(out)
        for encoder in self.encoders:
            out = encoder(out)
        out = out.view(out.size(0), -1)
        # out = torch.mean(out, 1)
        out = self.fc1(out)
        return out
class Encoder(nn.Module):
    def __init__(self, dim_model, num_head, hidden, dropout):
        super(Encoder, self).__init__()
        self.attention = Multi_Head_Attention(dim_model, num_head, dropout)
        self.feed_forward = Position_wise_Feed_Forward(dim_model, hidden, dropout)

    def forward(self, x):
        out = self.attention(x)
        out = self.feed_forward(out)
        return out
class Positional_Encoding(nn.Module):
    def __init__(self, embed, pad_size, dropout, device):
        super(Positional_Encoding, self).__init__()
        self.device = device
        self.pe = torch.tensor([[pos / (10000.0 ** (i // 2 * 2.0 / embed)) for i in range(embed)] for pos in range(pad_size)])
        self.pe[:, 0::2] = np.sin(self.pe[:, 0::2])
        self.pe[:, 1::2] = np.cos(self.pe[:, 1::2])
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        out = x + nn.Parameter(self.pe, requires_grad=False).to(self.device)
        out = self.dropout(out)
        return out
class Scaled_Dot_Product_Attention(nn.Module):
    '''Scaled Dot-Product Attention '''
    def __init__(self):
        super(Scaled_Dot_Product_Attention, self).__init__()

    def forward(self, Q, K, V, scale=None):
        '''
        Args:
            Q: [batch_size, len_Q, dim_Q]
            K: [batch_size, len_K, dim_K]
            V: [batch_size, len_V, dim_V]
            scale: 缩放因子 论文为根号dim_K
        Return:
            self-attention后的张量，以及attention张量
        '''
        attention = torch.matmul(Q, K.permute(0, 2, 1))
        if scale:
            attention = attention * scale
        # if mask:  # TODO change this
        #     attention = attention.masked_fill_(mask == 0, -1e9)
        attention = F.softmax(attention, dim=-1)
        context = torch.matmul(attention, V)
        return context
class Multi_Head_Attention(nn.Module):
    def __init__(self, dim_model, num_head, dropout=0.0):
        super(Multi_Head_Attention, self).__init__()
        self.num_head = num_head
        assert dim_model % num_head == 0
        self.dim_head = dim_model // self.num_head
        self.fc_Q = nn.Linear(dim_model, num_head * self.dim_head)
        self.fc_K = nn.Linear(dim_model, num_head * self.dim_head)
        self.fc_V = nn.Linear(dim_model, num_head * self.dim_head)
        self.attention = Scaled_Dot_Product_Attention()
        self.fc = nn.Linear(num_head * self.dim_head, dim_model)
        self.dropout = nn.Dropout(dropout)
        self.layer_norm = nn.LayerNorm(dim_model)

    def forward(self, x):
        batch_size = x.size(0)
        Q = self.fc_Q(x)
        K = self.fc_K(x)
        V = self.fc_V(x)
        Q = Q.view(batch_size * self.num_head, -1, self.dim_head)
        K = K.view(batch_size * self.num_head, -1, self.dim_head)
        V = V.view(batch_size * self.num_head, -1, self.dim_head)
        # if mask:  # TODO
        #     mask = mask.repeat(self.num_head, 1, 1)  # TODO change this
        scale = K.size(-1) ** -0.5  # 缩放因子
        context = self.attention(Q, K, V, scale)

        context = context.view(batch_size, -1, self.dim_head * self.num_head)
        out = self.fc(context)
        out = self.dropout(out)
        out = out + x  # 残差连接
        out = self.layer_norm(out)
        return out
class Position_wise_Feed_Forward(nn.Module):
    def __init__(self, dim_model, hidden, dropout=0.0):
        super(Position_wise_Feed_Forward, self).__init__()
        self.fc1 = nn.Linear(dim_model, hidden)
        self.fc2 = nn.Linear(hidden, dim_model)
        self.dropout = nn.Dropout(dropout)
        self.layer_norm = nn.LayerNorm(dim_model)

    def forward(self, x):
        out = self.fc1(x)
        out = F.relu(out)
        out = self.fc2(out)
        out = self.dropout(out)
        out = out + x  # 残差连接
        out = self.layer_norm(out)
        return out

3 结果讨论

        本文针对文本情感二分类任务展开训练，采用数据集的数据量包含Train有56700条，Evaluate有7000条。得到测试结果如下表。

        可以看到由于本文的数据量比较小，所以小模型还有更好的检测效果。如Transformer有点大材小用，缺少发挥空间。欢迎大家学习讨论。