本文从实践的角度，来讲一下如何构建LSTM+CNN的模型对文本进行分类。
本文Github
RNN网络与CNN网络可以分别用来进行文本分类。RNN网络在文本分类中，作用是用来提取句子的关键语义信息，根据提取的语义对文本进行区分；CNN的作用是用来提取文本的特征，根据特征进行分类。LSTM+CNN的作用，就是两者的结合，首先抽取文本关键语义，然后对语义提取关键特征。
需要了解CNN基本原理：https://zhuanlan.zhihu.com/p/28173972。
需要了解RNN基本原理：https://www.jianshu.com/p/32d3048da5ba。
个人认为基础知识讲解的还不错的博客。
数据来源
本实验是使用THUCNews的一个子集进行训练与测试，数据集请自行到THUCTC：一个高效的中文文本分类工具包下载，请遵循数据提供方的开源协议;
文本类别涉及10个类别：categories = ['体育', '财经', '房产', '家居', '教育', '科技', '时尚', '时政', '游戏', '娱乐']，每个分类6500条数据；
cnews.train.txt: 训练集(500010)
cnews.val.txt: 验证集(50010)
cnews.test.txt: 测试集(1000*10)
文本预处理
本文的预处理过程与文本分类--CNN大部分相同，其中有两处不同。
1.在CNN分类中，文本的长度padding到了600;本次padding到了300。
2.针对动态RNN的特点，增加计算每个batch中句子的真实长度。
代码如下：
def seq_length(x_batch):
real_seq_len = []
for line in x_batch:
real_seq_len.append(np.sum(np.sign(line)))
return real_seq_len
LSTM模型中的处理
定义占位符
self.input_x = tf.placeholder(tf.int32, shape=[None, pm.seq_length], name='input_x')
self.input_y = tf.placeholder(tf.float32, shape=[None, pm.num_classes], name='input_y')
self.length = tf.placeholder(tf.int32, shape=[None], name='rnn_length')
self.keep_pro = tf.placeholder(tf.float32, name='dropout')
self.global_step = tf.Variable(0, trainable=False, name='global_step')
embedding层
使用预训练词向量。
with tf.device('/cpu:0'), tf.name_scope('embedding'):
self.embedding = tf.get_variable("embeddings", shape=[pm.vocab_size, pm.embedding_dim],
initializer=tf.constant_initializer(pm.pre_trianing))
embedding_input = tf.nn.embedding_lookup(self.embedding, self.input_x)
LSTM层
with tf.name_scope('LSTM'):
cell = tf.nn.rnn_cell.LSTMCell(pm.hidden_dim, state_is_tuple=True)
Cell = tf.contrib.rnn.DropoutWrapper(cell, self.keep_pro)
output, _ = tf.nn.dynamic_rnn(cell=Cell, inputs=embedding_input, sequence_length=self.length, dtype=tf.float32)
以上为LSTM+CNN文本分类中，LSTM的环节。针对动态RNN的情形，一般来说，只需将每个batch中的句子padding到等长即可，但为了迁就CNN模型，所以须将所有句子padding到等长，计算batch中句子的真实长度，是动态RNN部分需要的，告诉动态RNN真实句子是多长，这样可以将填充的部分输出为0，不会将额外的信息带到CNN层中。
CNN层
为了将LSTM输出的结果是三维的tensor，而我们进行conv2d的CNN操作，需要四维tensor，故第一步是扩展维度。CNN环节参考文本分类--CNN。
with tf.name_scope('CNN'):
outputs = tf.expand_dims(outputs, -1) #[batch_size, seq_length, hidden_dim, 1]
pooled_outputs = []
for i, filter_size in enumerate(pm.filters_size):
filter_shape = [filter_size, pm.hidden_dim, 1, pm.num_filters]
w = tf.Variable(tf.truncated_normal(filter_shape, stddev=0.1), name='w')
b = tf.Variable(tf.constant(0.1, shape=[pm.num_filters]), name='b')
conv = tf.nn.conv2d(outputs, w, strides=[1, 1, 1, 1], padding='VALID', name='conv')
h = tf.nn.relu(tf.nn.bias_add(conv, b), name='relu')
pooled = tf.nn.max_pool(h, ksize=[1, pm.seq_length-filter_size+1, 1, 1],
strides=[1, 1, 1, 1], padding='VALID', name='pool')
pooled_outputs.append(pooled)
output_ = tf.concat(pooled_outputs, 3)
self.output = tf.reshape(output_, shape=[-1, 3*pm.num_filters])
全连接层
将CNN输出结果进行dropout与全连接进行相连。
with tf.name_scope('output'):
out_final = tf.nn.dropout(self.output, keep_prob=self.keep_pro)
o_w = tf.Variable(tf.truncated_normal([3*pm.num_filters, pm.num_classes], stddev=0.1), name='o_w')
o_b = tf.Variable(tf.constant(0.1, shape=[pm.num_classes]), name='o_b')
self.logits = tf.matmul(out_final, o_w) + o_b
self.predict = tf.argmax(tf.nn.softmax(self.logits), 1, name='score')
Loss
这里使用softmax交叉熵求loss, logits=self.scores 这里一定用的是未经过softmax处理的数值。
with tf.name_scope('loss'):
cross_entropy = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.logits, labels=self.input_y)
self.loss = tf.reduce_mean(cross_entropy)
optimizer
这里使用了梯度裁剪。首先计算梯度，这个计算是类似L2正则化计算w的值，也就是求平方再平方根。然后与设定的clip裁剪值进行比较，如果小于等于clip,梯度不变；如果大于clip,则梯度*（clip/梯度L2值）。
with tf.name_scope('optimizer'):
# 退化学习率 learning_rate = lr*(0.9**(global_step/10);staircase=True表示每decay_steps更新梯度
# learning_rate = tf.train.exponential_decay(self.config.lr, global_step=self.global_step,
# decay_steps=10, decay_rate=self.config.lr_decay, staircase=True)
# optimizer = tf.train.AdamOptimizer(learning_rate)
# self.optimizer = optimizer.minimize(self.loss, global_step=self.global_step) #global_step 自动+1
# no.2
optimizer = tf.train.AdamOptimizer(pm.learning_rate)
gradients, variables = zip(*optimizer.compute_gradients(self.loss)) # 计算变量梯度，得到梯度值,变量
gradients, _ = tf.clip_by_global_norm(gradients, pm.clip)
# 对g进行l2正则化计算，比较其与clip的值，如果l2后的值更大，让梯度*(clip/l2_g),得到新梯度
self.optimizer = optimizer.apply_gradients(zip(gradients, variables), global_step=self.global_step)
# global_step 自动+1
accuracy
最后，计算模型的准确度。
with tf.name_scope('accuracy'):
correct = tf.equal(self.predict, tf.argmax(self.input_y, 1))
self.accuracy = tf.reduce_mean(tf.cast(correct, tf.float32), name='accuracy')
训练模型
global_step为100的倍数时，输出当前batch的训练loss,训练accuracy,在测试batch上的loss,accuracy；并每迭代完一次，保存一次模型。
x_train, y_train = process(pm.train_filename, wordid, cat_to_id, max_length=300)
x_test, y_test = process(pm.test_filename, wordid, cat_to_id, max_length=300)
for epoch in range(pm.num_epochs):
print('Epoch:', epoch+1)
num_batchs = int((len(x_train) - 1) / pm.batch_size) + 1
batch_train = batch_iter(x_train, y_train, batch_size=pm.batch_size)
for x_batch, y_batch in batch_train:
real_seq_len = seq_length(x_batch)
feed_dict = model.feed_data(x_batch, y_batch, real_seq_len, pm.keep_prob)
_, global_step, _summary, train_loss, train_accuracy = session.run([model.optimizer, model.global_step, merged_summary,
model.loss, model.accuracy], feed_dict=feed_dict)
if global_step % 100 == 0:
test_loss, test_accuracy = model.test(session, x_test, y_test)
print('global_step:', global_step, 'train_loss:', train_loss, 'train_accuracy:', train_accuracy,
'test_loss:', test_loss, 'test_accuracy:', test_accuracy)
if global_step % num_batchs == 0:
print('Saving Model...')
saver.save(session, save_path, global_step=global_step)
由于小霸王运行非常吃力，因此只进行了3次迭代。但从迭代的效果来看，结果很理想。在训练集的batch中最好达到100%，同时测试集达到100%准确。
验证模型
验证集有5000条语句，我用最后一次保存的模型，对5000条句子进行预测，将预测的结果与原标签进行对比，得到验证集上的准确率，结果表明在整个验证集上准确达到97.7%，并输出前10条语句，将预测结果与原结果进行对比。
def val():
pre_label = []
label = []
session = tf.Session()
session.run(tf.global_variables_initializer())
save_path = tf.train.latest_checkpoint('./checkpoints/Lstm_CNN')
saver = tf.train.Saver()
saver.restore(sess=session, save_path=save_path)
val_x, val_y = process(pm.val_filename, wordid, cat_to_id, max_length=pm.seq_length)
batch_val = batch_iter(val_x, val_y, batch_size=64)
for x_batch, y_batch in batch_val:
real_seq_len = seq_length(x_batch)
feed_dict = model.feed_data(x_batch, y_batch, real_seq_len, 1.0)
pre_lab = session.run(model.predict, feed_dict=feed_dict)
pre_label.extend(pre_lab)
label.extend(y_batch)
return pre_label, label
整个模型的流程，分析完毕。因学识有限，文中难免有描述不对的地方，请各位批评指正。
