cnn文本分类python实现_Tensorflow实现CNN文本分类

摘要：本文主要是用于学习。从实践中出发，利用TensorFlow解决NLP中的分类问题，主要包括多分类、多标签分类问题。我打算学习深度学习中的不同算法进行探讨研究，主要包括CNN、LSTM、Fasttext、seq2seq等一系列算法，在实际应用中的一些问题及track。这是本系列的第一篇文章，主要介绍了CNN卷积神经网络的原理，以及使用Tensorflow实现CNN文本分类的编码实现。

CNN卷积神经网络简介

神经网络Neural Networks方面的研究在国外是从很早很早就已经开始发展了，从最开始的浅层神经网络ANN算法研究，到BP反馈神经网络的发展，以及现在非常火的深度学习神经网络。都是想要对单个神经元进行建模，模拟人脑神经网络系统的功能，从而构建一个网络，具有学习的能力。BP神经网络，深度学习神经网络都是遵循一个最基本的特点：前向传播数据信号，反向传播误差值。从而让神经网络学习拟合到一个较好的状态。

卷积层

对于卷积层，其中核心即是通过卷积核(filter)计算提取特征feature map。对于卷积操作而言，通过每一个filter和input卷积计算，则会得到一个新的二维数组，可以理解为对原始输入进行特征提取，一般表示为feature map，filter的个数影响feature map的数量，卷积层的输出维度则和卷积核以及输入相关，一般计算卷积输出有公式如下,其中W：输入；F：卷积核；P：0填充；S：步长。

feature map 长度计算公式

在整个计算卷积计算的过程中，主要有两个重要的特性：1.局部连通 2.参数共享

1. 局部连通：CNN和全连接神经网络不一样的地方在于，CNN的神经元和下一层的神经元并不是全连接的，而是通过不同的卷积核(filter)，针对样本某一局部的数据窗口进行卷积计算，卷积核就好比学习对象，不同的卷积核对同样的输入样本进行学习、特征提取，最好的即是每一个卷积核都提取到样本不同的特征，比如对于图片而言，不同的filter可能提取图片的颜色深浅，轮廓等特征，每个filter都是对输入数据的局部进行计算处理，这就是CNN的局部连通特点。

2. 参数共享：对于同一个filter而言，可以当成是提取特征的容器，用相同的filter提取特征，而与样本的输入位置无关，表示在输入样本的所有区域，都能够使用相同的学习特征，虽然样本局部的数据在变化，可是每一个filter的权重是固定不变的，这个即是CNN的参数共享特点，它降低了整个网络的复杂性。

池化层

在CNN网络中另外一个非常重要的操作则是池化操作，池化可以将一幅大的图像缩小，同时又保留其中的重要信息。 它就是将输入图像进行缩小，减少像素信息，只保留重要信息。通常情况下，池化都是22大小，比如对于max-pooling来说，就是取输入图像中22大小的块中最大值，作为结果的像素值，相当于将原始图像缩小了4倍。(注：同理，对于average-pooling来说，就是取2*2大小块的平均值作为结果的像素值。)因为最大池化(max-pooling)保留了每一个小块内的最大值，所以它相当于保留了这一块最佳的匹配结果(因为值越接近1表示匹配越好)。这也就意味着它不会具体关注窗口内到底是哪一个地方匹配了，

Tensorflow简介

对于Tensorflow,我想现在大部分的研究人员都不陌生，可是为什么Tensorflow在整个深度学习领域会变得如此的流行？毫无疑问的是，因为Tensorflow的流行让深度学习的门槛变得越来越低了，只要有python和机器学习基础，使得实现以及应用神经网络模型变得非常简单易上手。以前要编码实现一个神经网络，需要对前馈传播，反向传播有很深刻的理解，并需要花费一定的时间进行编码开发，所以Tensorflow的出现，大大降低了深度神经网络的开发成本和开发难度，使得算法研究人员能够快速验证算法的适用性，能够将更多的精力放到网络的设计以及性能的调优。Tensorflow是很强大的，它支持Python和C++，也可以使用CPU和GPU的分布式计算，除了Tensorflow，现在也有很多封装更高层的库支持进行深度神经网络计算，如Theano,Keras,Torch,MXnet等，其中Keras使用是非常简单的，他支持Theano,Tensorflow，只需要几行代码就可以构建一个神经网络。大家感兴趣的话，可以了解并学习比较一下Keras和Tensorflow实现相同的功能时需要的代码。

关于Tensorflow，还有一个比较有意思的是可视化功能，一方面是我们可以直接看到自己设计的网络结构；另一方面，我们可以将我们想要关注的参数通过图表的形式记录下来，通过关注图表变化趋势，可以更方便后期我们对模型的调优与测试。如下所示为使用tensorboard绘制的图像。

卷积层

loss

Word2Vec简介

因为在自然语言处理(NLP)任务中，使用神经网络进行计算的时候往往都需要将文本信息用矩阵的形式表达，所以作为NLP中一个非常重要的工具Word2Vec，通过word2vec对数据进行训练得到的结果——词向量(word wmbedding)即可很好的完成这样一个工作。其实word2vec只是一个工具，在其背后其实主要是指Cbow模型和Skip-gram模型的一个浅层神经网络，通过该模型可以在大量的数据集上进行训练，最终得到词向量。通过python使用gensim库可以很方便的进行word2vec的训练。

词向量有什么用？通过向量表示词语，这使得在处理很多NLP任务的时候，变得更为方便，如计算词语的相似性，可以直接对词向量进行tf-idf进行计算处理，通过词向量来度量词与词之间的相似性；比如在训练神经网络的时候，可以将词向量作为网络输入。

Tensorflow实现CNN文本分类

本文主要是想要在实践中学习Tensorflow及一些基本的文本分类算法，CNN在计算机视觉领域取得了很好的结果，其实在NLP分类任务中，CNN也是具有很好的效果。因为CNN是有监督学习算法，所以想要基于CNN进行文本分类，主要包含数据预处理、网络模型构建。

进行数据预处理

如果想要一个神经网络有比较好的效果，数据占据着非常重要的地位，训练集的数量以及训练集的质量都是非常重要的因素。为了能够在训练过程中直观的看到训练效果，我们可以将数据集拆分为训练集以及验证集，用于在训练过程中对数据进行校验。

网络模型构建

前面在描述了CNN的基本原理外，我们也清楚NLP中往往是将文本矩阵化表示，所以我们需要清楚，在使用一个矩阵表示文本的时候，矩阵中的每一行都对应于一个元素，一般是一个词语，即表明矩阵中的每一行都是一个元素的向量化表示。想要构建一个有效的CNN网络，其中主要需要控制词向量大小，以及进行卷积计算的卷积核大小及卷积核个数。

我觉得下面这个图很形象的描述了CNN网络在NLP中的应用，下面可以可以从左往右分析一下整个算法的应用过程：

第1层表示为输入层，输入为一个短句，每个字通过word2vec来表示为一个行向量，表示为一个二维矩阵(实际使用卷积层应该为4维矩阵);

第2层我们可以看到设置了3种不同尺寸的卷积核，表示为filter_size:[2,3,4]，其中表示每个卷积核进行卷积计算获取特征的词个数

(相邻2个字，相邻3个字，相邻4个字)，其中每种尺寸卷积核的个数为2，所以在第二层中一共包含6个卷积核，3种卷积核，每种卷积核的列数和输入数据为列数一致。

将第2层中的卷积核和第一层中的矩阵输入进行卷积计算，获取到的结果即为第3层，即生成6个feature map

第3层中每个卷积核生成的feature map进行max pool最大池化，即取得所有输出的最大值，进行concat聚合操作，这样即得到CNN抽取出的所有特征。

4层结果和最后一层输出层进行全连接操作，输出个数根据实际应用进行设置。

这样，就完成了一个CNN文本分类的操作，具体损失函数，优化函数的计算，都是可以直接通过tensorflow调用。

cnn文本分类

接下来，我们从编码实现的角度谈一下应该怎么从0开始构建一个cnn神经网络用语文本分类。了解Tensorflow的小伙伴应该清楚，使用Tensorflow的时候，是需要我们先定义把整个网络结构，其中包括通过占位符placeholder为待训练数据占坑，使用Variable或get_variable设置训练过程中所需要的一些变量，如下表示：

定义输入变量、网络训练过程中的一些参数：

print('定义占位符，输入输出变量.....')

self.input_x = tf.placeholder(tf.int32, [None, self.sequence_length], name="input_x")

self.input_y = tf.placeholder(tf.int32, [None,], name="input_y")

self.global_step = tf.Variable(0, trainable=False, name="global_step")

self.epoch_step = tf.Variable(0, trainable=False, name="epoch_step")

self.initializer = tf.random_normal_initializer(stddev=0.1)

定义Embedding，全连接层的权重W以及偏置b

def instantiate_weights(self):

'''

初始化网络参数

Args:

Embedding:[self.vocab_size, self.embed_size]

W_projection:[self.num_filter_total, self.num_classes]

b_projection:[self.num_classes]

'''

with tf.name_scope("Variables"):

with tf.name_scope("Embedding"):

self.Embedding = tf.get_variable("Embedding",

shape=[self.vocab_size, self.embed_size], initializer=self.initializer)

with tf.name_scope("W_projection"): #计算输出层的参数

self.W_projection = tf.get_variable("W_projection",

shape=[self.num_filters_total, self.num_classes], initializer=self.initializer)

variable_summaries(self.W_projection)

with tf.name_scope("b_projection"):

self.b_projection = tf.get_variable("b_projection",

shape=[self.num_classes])

variable_summaries(self.b_projection)

接下来当然到了最核心的部分，应该怎么设计网络结构，使得我们的模型能够发挥它最大的作用呢？其实这个问题我也不太清楚，不过基本的都是Conv2d->activation(可以省略)->Pool，其实主要还是根据效果，慢慢的对网络进行调整。

def inference(self):

'''

构建网络结构

Args:

Conv.Input:[filter_height, filter_width, in_channels, out_channels]

Conv.Returns:[batch_size,sequence_length-filter_size+1,1,num_filters]

input_data:NHWC:[batch, height, width, channels]

pool.Input:[batch, height, width, channels]

Returns:

网络结构每次训练返回的结果:[batch_size, self.num_classes]

'''

with tf.name_scope("Layer_Embedding"):

#[None, sentence_length, embed_size]

self.embedded_words = tf.nn.embedding_lookup(self.Embedding, self.input_x)

self.sentence_embeddings_expanded = tf.expand_dims(self.embedded_words, -1,

name="embedding_word") #[None, sentence_length, embed_size, 1]

pooled_outputs = []

with tf.name_scope("Conv2d"):

for i, filter_size in enumerate(self.filter_sizes):

with tf.name_scope("convolution-%s" %filter_size):

filter = tf.get_variable("filter-%s"%filter_size,

[filter_size,self.embed_size,1,self.num_filters], initializer=self.initializer)

#[batch_size, self.sequence_size-filter_size, 1, 1]

conv = tf.nn.conv2d(self.sentence_embeddings_expanded, filter,

strides=[1,1,1,1], padding="VALID", name="conv")

with tf.name_scope("relu-%s"%filter_size):

b = tf.get_variable("b-%s"%filter_size, [self.num_filters])

h = tf.nn.relu(tf.nn.bias_add(conv, b), "relu")

with tf.name_scope("pool-%s"%filter_size):

pooled = tf.nn.max_pool(h, ksize=[1,self.sequence_length-filter_size+1,1,1],

strides=[1,1,1,1], padding="VALID", name="pool")

pooled_outputs.append(pooled)

with tf.name_scope("Pool_Flat"):

self.h_pool = tf.concat(pooled_outputs,3) #[batch_size, 1, 1, num_filters_total]

self.h_pool_flat = tf.reshape(self.h_pool, [-1,self.num_filters_total])

if self.is_dropout:

print('需要dropout操作')

with tf.name_scope("DropOut"):

self.h_drop = tf.nn.dropout(self.h_pool_flat, keep_prob=self.dropout_keep_prob)

with tf.name_scope("Output"):

#tf.matmul([None,self.embed_size],[self.embed_size,self.num_classes])

logits = tf.matmul(self.h_pool_flat, self.W_projection) + self.b_projection #[None, self.num_classes]

return logits

熟悉神经网络的小伙伴应该清楚，在训练网络的时候，其实只有神经网络的输出是不行的，最重要的是应该根据每一次的输出结果和标准输出

进行损失值计算，再根据梯度下降算法逐步的调整网络参数，让整个网络更好的拟合数据。

如下为计算loss的过程：

def loss(self, l2_lambda=0.0001):

'''

根据每次训练的预测结果和标准结果比较，计算误差

loss = loss + l2_lambda*1/2*||variables||2

Args:

l2_lambda:超参数，l2正则，保证l2_loss和train_loss在同一量级

Returns:

每次训练的损失值loss

'''

with tf.name_scope("Loss"):

losses = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.input_y, logits=self.logits)

loss = tf.reduce_mean(losses)

if self.is_l2:

print("需要对loss进行l2正则化")

l2_losses = tf.add_n([tf.nn.l2_loss(v) for v in tf.trainable_variables() if 'bias' not in v.name]) * l2_lambda

loss = loss + l2_losses

variable_summaries(loss)

return loss

如下为梯度下降：

def train(self):

'''

通过梯度下降最小化损失loss的操作

Args:

Returns:

返回包含了训练操作(train_op)输出结果的tensor

'''

if self.is_decay:

print("需要对学习率进行指数衰减")

with tf.name_scope("LearningRate"):

#学习率指数衰减 learning_rate=learning_rate*decay_rate^(global_step/decay_steps)

learning_rate = tf.train.exponential_decay(self.learning_rate, self.global_step,

self.decay_steps, self.decay_rate, staircase=True)

with tf.name_scope("Train"):

optimizer = tf.train.GradientDescentOptimizer(self.learning_rate)

train_op = optimizer.minimize(self.loss_val, global_step=self.global_step)

#train_op = tf.contrib.layers.optimize_loss()

return train_op

模型优化改进

至此，我就完成了一个基本的CNN神经网络可以用于文本分类，训练数据大概100W，一共4个类别。实践证明，CNN的效果还是挺好的,在对batch_size,learning_rate,filter_size,num_filters,进行调整以后，整个网络模型的效果在验证集上即有97%的准确率。

在这个基础上，针对Embedding层，如果直接加载预训练的word2vec词向量，对分类效果会不会有帮助呢？为了防止Overfitting，在输出层添加dropout对模型会有帮助吗？在计算loss的时候，通过L2正则化以及训练过程中learning_rate动态更新，对模型的影响是什么？所以我进行了验证，结果如下：

添加预训练word2vec向量，分类结果96%；

L2正则，分类结果97.1%；

dropout、learning_rate衰减没有明显变化

参考文献