1. 引言
前面介绍了LSTM_CNN文本分类模型，虽然在CNN前加上一层LSTM层，可以提取文本中的序列信息，但是当文本的长度比较长时，LSTM提取信息的能力是有限的，并且，在LSTM中，每个词汇对应的隐藏状态都只包含了前面序列的信息，而没有考虑到后续序列的信息（BiLSTM除外），因此，本文将介绍一个新的模型结构，该结构采用一种递归CNN的形式，即每个词汇的向量表示既包括了其本身的词向量，也包括其前面序列和后面序列的上下文向量，从而使得每个词汇的向量信息更加丰富。
- RCNN论文地址：《Recurrent Convolutional Neural Networks for Text Classification》
2. RCNN模型介绍
2.1 RCNN模型的结构
首先，对于每一个文本
，用一串词汇序列
表示，并且记该文本属于某一类别
的概率为
，其中，
表示模型中的参数。RCNN模型主要包含三部分，分别是递归CNN层、max-pooling层、输出层。 在递归CNN层，对于每个词汇，RCNN会递归地计算其左侧上下文向量和右侧上下文向量，然后将这两部分向量与当前词汇的词向量进行拼接作为该词汇的向量表示，如图1所示。记
、
分别为词汇
的左侧上下文向量和右侧上下文向量，它们都是长度为
的实数向量，计算公式分别如下：
其中，
、
分别表示前一个词汇
和后一个词汇
的词向量，其向量长度为
，
、
分别表示前一个词汇
的左侧上下文向量和后一个词汇的右侧上下文向量，对于每个文本的第一个词汇的左侧上下文向量和最后一个词汇的右侧上下文向量，分别采用共享的参数向量
、
表示，
、
、
、
为权重矩阵，
为一个非线性激活函数。接着，将这三个向量拼接起来作为当前词汇的向量表示，这样一来，每个词汇的向量就囊括了左侧和右侧的语义信息，使得词汇的向量表示更具有区分性，其表示如下：
当获取到每个词汇的向量表示
后，RCNN会将每个向量传入一个带有tanh激活函数的全连接层，其计算公式如下：
其中，
为潜在的语义向量。 在max-pooling层，RCNN将每个潜在语义向量
传入一个max-pooling层，获取所有向量中最重要的元素，其计算公式如下：
得到的向量
即为整个文本的向量表示。
在输出层，RCNN与其他传统的文本分类模型相似，将得到的文本向量传入一个带有softmax的全连接层，得到当前文本的在各个类别的概率分布，其计算公式如下：
图1 RCNN模型结构
3. RCNN模型的tensorflow实现
本文利用tensorflow对RCNN进行了复现，并将其在之前的情感分析数据集上进行训练，有关数据集的介绍请参见之前的文章《FastText文本分类与tensorflow实现》，RCNN的模型代码如下：
import os
import numpy as np
import tensorflow as tf
from eval.evaluate import accuracy
from tensorflow.contrib import slim
from loss.loss import cross_entropy_loss
class RCNN(object):
def __init__(self,
num_classes,
seq_length,
vocab_size,
embedding_dim,
learning_rate,
learning_decay_rate,
learning_decay_steps,
epoch,
dropout_keep_prob,
context_dim,
hidden_dim):
self.num_classes = num_classes
self.seq_length = seq_length
self.vocab_size = vocab_size
self.embedding_dim = embedding_dim
self.learning_rate = learning_rate
self.learning_decay_rate = learning_decay_rate
self.learning_decay_steps = learning_decay_steps
self.epoch = epoch
self.dropout_keep_prob = dropout_keep_prob
self.context_dim = context_dim
self.hidden_dim = hidden_dim
self.input_x = tf.placeholder(tf.int32, [None, self.seq_length], name='input_x')
self.input_y = tf.placeholder(tf.float32, [None, self.num_classes], name='input_y')
self.model()
def model(self):
# 词向量映射
with tf.name_scope("embedding"):
embedding = tf.get_variable('embedding', [self.vocab_size, self.embedding_dim])
embedding_inputs = tf.nn.embedding_lookup(embedding, self.input_x)
# Recurrent Structure（CNN）
with tf.name_scope("bi_rnn"):
fw_cell = tf.nn.rnn_cell.BasicLSTMCell(self.context_dim)
fw_cell = tf.nn.rnn_cell.DropoutWrapper(fw_cell, output_keep_prob=self.dropout_keep_prob)
bw_cell = tf.nn.rnn_cell.BasicLSTMCell(self.context_dim)
bw_cell = tf.nn.rnn_cell.DropoutWrapper(bw_cell, output_keep_prob=self.dropout_keep_prob)
(output_fw, output_bw), states = tf.nn.bidirectional_dynamic_rnn(cell_fw=fw_cell,
cell_bw=bw_cell,
inputs=embedding_inputs,
dtype=tf.float32)
with tf.name_scope("context"):
shape = [tf.shape(output_fw)[0], 1, tf.shape(output_fw)[2]]
c_left = tf.concat([tf.zeros(shape), output_fw[:, :-1]], axis=1, name="context_left")
c_right = tf.concat([output_bw[:, 1:], tf.zeros(shape)], axis=1, name="context_right")
with tf.name_scope("word_representation"):
y2 = tf.concat([c_left, embedding_inputs, c_right], axis=2, name="word_representation")
embedding_size = 2 * self.context_dim + self.embedding_dim
# max_pooling层
with tf.name_scope("max_pooling"):
fc = tf.layers.dense(y2, self.hidden_dim, activation=tf.nn.relu, name='fc1')
fc_pool = tf.reduce_max(fc, axis=1)
# output层
with tf.name_scope("output"):
self.logits = tf.layers.dense(fc_pool, self.num_classes, name='fc2')
self.y_pred_cls = tf.argmax(tf.nn.softmax(self.logits), 1, name="pred")
# 损失函数
self.loss = cross_entropy_loss(logits=self.logits, labels=self.input_y)
# 优化函数
self.global_step = tf.train.get_or_create_global_step()
learning_rate = tf.train.exponential_decay(self.learning_rate, self.global_step,
self.learning_decay_steps, self.learning_decay_rate,
staircase=True)
optimizer = tf.train.AdamOptimizer(learning_rate)
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
self.optim = slim.learning.create_train_op(total_loss=self.loss, optimizer=optimizer, update_ops=update_ops)
# 准确率
self.acc = accuracy(logits=self.logits, labels=self.input_y)
def fit(self, train_x, train_y, val_x, val_y, batch_size):
# 创建模型保存路径
if not os.path.exists('./saves/rcnn'): os.makedirs('./saves/rcnn')
if not os.path.exists('./train_logs/rcnn'): os.makedirs('./train_logs/rcnn')
# 开始训练
train_steps = 0
best_val_acc = 0
# summary
tf.summary.scalar('val_loss', self.loss)
tf.summary.scalar('val_acc', self.acc)
merged = tf.summary.merge_all()
# 初始化变量
sess = tf.Session()
writer = tf.summary.FileWriter('./train_logs/rcnn', sess.graph)
saver = tf.train.Saver(max_to_keep=10)
sess.run(tf.global_variables_initializer())
for i in range(self.epoch):
batch_train = self.batch_iter(train_x, train_y, batch_size)
for batch_x, batch_y in batch_train:
train_steps += 1
feed_dict = {self.input_x: batch_x, self.input_y: batch_y}
_, train_loss, train_acc = sess.run([self.optim, self.loss, self.acc], feed_dict=feed_dict)
if train_steps % 1000 == 0:
feed_dict = {self.input_x: val_x, self.input_y: val_y}
val_loss, val_acc = sess.run([self.loss, self.acc], feed_dict=feed_dict)
summary = sess.run(merged, feed_dict=feed_dict)
writer.add_summary(summary, global_step=train_steps)
if val_acc >= best_val_acc:
best_val_acc = val_acc
saver.save(sess, "./saves/rcnn/", global_step=train_steps)
msg = 'epoch:%d/%d,train_steps:%d,train_loss:%.4f,train_acc:%.4f,val_loss:%.4f,val_acc:%.4f'
print(msg % (i, self.epoch, train_steps, train_loss, train_acc, val_loss, val_acc))
sess.close()
def batch_iter(self, x, y, batch_size=32, shuffle=True):
"""
生成batch数据
:param x: 训练集特征变量
:param y: 训练集标签
:param batch_size: 每个batch的大小
:param shuffle: 是否在每个epoch时打乱数据
:return:
"""
data_len = len(x)
num_batch = int((data_len - 1) / batch_size) + 1
if shuffle:
shuffle_indices = np.random.permutation(np.arange(data_len))
x_shuffle = x[shuffle_indices]
y_shuffle = y[shuffle_indices]
else:
x_shuffle = x
y_shuffle = y
for i in range(num_batch):
start_index = i * batch_size
end_index = min((i + 1) * batch_size, data_len)
yield (x_shuffle[start_index:end_index], y_shuffle[start_index:end_index])
def predict(self, x):
sess = tf.Session()
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(tf.global_variables())
ckpt = tf.train.get_checkpoint_state('./saves/rcnn/')
saver.restore(sess, ckpt.model_checkpoint_path)
feed_dict = {self.input_x: x}
logits = sess.run(self.logits, feed_dict=feed_dict)
y_pred = np.argmax(logits, 1)
return y_pred在训练时，RCNN模型的LSTM隐藏层维度设置为200，前后文向量的维度也是设置为200，中间全连接层的隐藏层维度也是设置为200，其他的参数与之前FastText模型的一致，最终的模型在验证集上的效果如图2所示，其中，在经过762000次迭代后，模型在验证集上的准确率达到最高，为95.1%，在3000个测试集上的准确率是97.87%，比之前的LSTM_CNN大概高0.1%，可以发现RCNN在文本分类任务上的效果还是比较不错的。
图2 RCNN模型训练效果
4. 总结
最终，对RCNN模型做个总结吧：
- RCNN对词汇的向量表示进行拓展，加入了前、后上下文向量，可以捕捉更大范围的上下文信息。
- 训练速度上还是没有FastText、TextCNN快
