文本分类(一) | (5) RCNN

项目Github地址

本篇博客主要介绍基于RCNN的文本分类算法的原理及实现细节。

目录

1. 分类原理

2. 实现细节

---

1. 分类原理

上图中中间是输入文本中每个单词的嵌入表示，左右使用双向RNN分别学习当前词的左上下文表示和右上下文表示,与当前词本身的词向量连接，构成后续卷积层的输入。具体如下： 

与TextCNN比较类似，都是把文本表示为一个嵌入矩阵，再进行卷积操作。不同的是TextCNN中的文本嵌入矩阵每一行只是文本中一个词的向量表示，而在RCNN中，文本嵌入矩阵的每一行是当前词的词向量以及上下文嵌入表示的拼接。

例如：上图中的along这一个单词，中间是他的词向量，左边利用一个RNN得到along之前上文所有单词的嵌入表示，右边同样利用一个反向的RNN得到along之后所有单词的嵌入表示。三者共同构成along的嵌入表示，文本中的其他词同理。最后文本被表示为上图左边的一个嵌入矩阵。

然后将作为当前词的嵌入表示，输入到卷积核大小为1*d(d为的长度)激活函数为tanh的卷积层，得到潜在的语义向量：

在TextCNN中我们曾经设置了多个卷积核f*d,RCNN中将卷积核大小设置为1*d的原因是中已经包含了左右上下文的信息，无需再使用窗口大于1的卷积核进行特征提取。需要说明的是，实践中依然可以同时使用多个不同大小的卷积核，如[1,2,3],可能会取得更好的实践效果，一种解释是窗口大于1的卷积核强化了左右最近的上下文信息。此外实践中一般使用更复杂的RNN来捕捉的上下文信息，如LSTM和GRU等。

在经过卷积层以后，获得了文本中所有词的语义表示,然后经过一个max-pooling层和softmax层(输出层使用softmax激活函数)进行分类：

2. 实现细节

class RCNN(BasicModule):#继承自BasicModule 其中封装了保存加载模型的接口,BasicModule继承自nn.Module

    def __init__(self,vocab_size,opt):#opt是config类的实例 里面包括所有模型超参数的配置

        super(RCNN, self).__init__()
        # 嵌入层
        self.embedding = nn.Embedding(vocab_size, opt.embed_size)#词嵌入矩阵 每一行代表词典中一个词对应的词向量；
        # 词嵌入矩阵可以随机初始化连同分类任务一起训练，也可以用预训练词向量初始化（冻结或微调）

        #双向lstm 由于RCNN中双向lstm一般只有一层 所以opt.drop_prop_rcnn=0.0(丢弃率)
        self.lstm = nn.LSTM(opt.embed_size,opt.recurrent_hidden_size,num_layers=opt.num_layers_rcnn,
                            bidirectional=True,batch_first=True,dropout=opt.drop_prop_rcnn)

        #全连接层 维度转换 卷积操作可以用全连接层代替
        self.linear = nn.Linear(2*opt.recurrent_hidden_size+opt.embed_size,opt.recurrent_hidden_size)

        #池化层
        self.max_pool = nn.MaxPool1d(opt.max_len)

        #全连接层分类
        self.content_fc = nn.Sequential(
            nn.Linear(opt.recurrent_hidden_size, opt.linear_hidden_size),
            nn.BatchNorm1d(opt.linear_hidden_size),
            nn.ReLU(inplace=True),
            nn.Dropout(opt.drop_prop),
            # 可以再加一个隐层
            # nn.Linear(opt.linear_hidden_size,opt.linear_hidden_size),
            # nn.BatchNorm1d(opt.linear_hidden_size),
            # nn.ReLU(inplace=True),
            # 输出层
            nn.Linear(opt.linear_hidden_size, opt.classes)
        )

    def forward(self, inputs):
        #inputs(batch_size,seq_len)
        # 由于batch_first = True 所以inputs不用转换维度
        embeddings = self.embedding(inputs)  # (batch_size, seq_len, embed_size)

        outputs,_ = self.lstm(embeddings) #(batch_size, seq_len, recurrent_hidden_size*2)

        #将前后向隐藏状态和embedding拼接
        outputs = torch.cat((outputs[:,:,:outputs.size(2)//2],embeddings,outputs[:,:,outputs.size(2)//2:]),dim=2) #(batch_size, seq_len, embed_size+recurrent_hidden_size*2)

        #做维度转换
        outputs = self.linear(outputs) #(batch_size, seq_len, recurrent_hidden_size)

        #沿seq_len维做最大池化（全局池化）
        #先调整维度 交换recurrent_hidden_size维和seq_len维
        #即把recurrent_hidden_size作为通道维 符合一维池化的输入
        outputs = outputs.permute(0,2,1)  #(batch_size,recurrent_hidden_size,seq_len)
        outputs = self.max_pool(outputs).squeeze(2)   #(batch_size,recurrent_hidden_size)

        #通过全连接层 分类
        outputs = self.content_fc(outputs) #(batch_size,classes)

        return outputs