Tensorflow版TextCNN主要代码解析

本文转载自:http://blog.csdn.net/u013818406/article/details/69530762

上一篇转载了一些大规模文本分类的方法，其中就有TextCNN，这篇博客就主要解析一下Tensorflow版TextCNN的主要代码。

[python]  view plain  copy

1. import tensorflow as tf  
2. import numpy as np  
3.   
4.   
5. class TextCNN(object):  
6.     """ 
7.     A CNN for text classification. 
8.     Uses an embedding layer, followed by a convolutional, max-pooling and softmax layer. 
9.     """  
10.     def __init__(  
11.       self, sequence_length, num_classes, vocab_size,  
12.       embedding_size, filter_sizes, num_filters, l2_reg_lambda=0.0):  

首先导入了tensorflow与numpy包，然后代码主要是建立一个可复用的TextCNN类，类的初始化参数

sequence_length：CNN需要固定输入与输出，所以每个句子的输入都是定长*词向量长度，定长一般设为最大句子长度，如果输入的句子词数没到定长就补充零，补充的零对后面的结果没有影响，因为后面的max-pooling只会输出最大值，补零的项会被过滤掉

num_classes：输出的文本类别总数也就是文本中有几个类别

vocab_size：字典大小，在之前的文本预处理阶段需要对文本进行分词与对单词进行编号，在训练的时候也是输入单词的id然后再词向量化，字典大小用通俗的话来说就是文本中出现了多少个词

embedding_size：嵌入长度，指的是词向量长度也就是用一个多大维的向量来表示词语，一般来说根据文本的规模定词向量的维度大小，样本数太少时使用较大维的词向量会造成难以收敛与容易过拟合的问题，有的TextCNN在这里会有一些区别，有的会采用固定的word2vec、fasttext、glove预先训练好的词向量

filter_sizes：卷积核大小的List，TextCNN里面的卷积和大小其实对应了传统NLP的n元语法的概念，这里的卷积核都是filter_size*embedding_size，其实就是filter_size个词作为一个整体来考虑，也可以理解为中文中有的词是一个字有的词是两个字，在不同卷积核的情况下对应数量字数的词会表现出更好的效果

num_filters：每个卷积核大小对应的卷积核个数，这里为了偷了一点懒，将不同大小卷积核的数量都设为一个常量

l2_reg_lambda：这个就是L2正则的权值，就不多解释了

[python]  view plain  copy

1. # Placeholders for input, output and dropout  
2.         self.input_x = tf.placeholder(tf.int32, [None, sequence_length], name="input_x")  
3.         self.input_y = tf.placeholder(tf.float32, [None, num_classes], name="input_y")  
4.         self.dropout_keep_prob = tf.placeholder(tf.float32, name="dropout_keep_prob")  
5.   
6.         # Keeping track of l2 regularization loss (optional)  
7.         l2_loss = tf.constant(0.0)  

定义了输入与输出、dropout比例的占位符，设立了一个常量记录L2正则损失，每当出现新的变量时就会用变量的L2正则损失乘上L2正则损失权值加入到这个l2_loss里面来。

[python]  view plain  copy

1. # Embedding layer  
2.        with tf.device('/cpu:0'), tf.name_scope("embedding"):  
3.            W = tf.Variable(  
4.                tf.random_uniform([vocab_size, embedding_size], -1.0, 1.0),  
5.                name="W")  
6.            self.embedded_chars = tf.nn.embedding_lookup(W, self.input_x)  
7.            self.embedded_chars_expanded = tf.expand_dims(self.embedded_chars, -1)  

定义了词嵌入矩阵，将输入的词id转化成词向量，这里的词嵌入矩阵是可以训练的，最后将词向量结果增加了一个维度，为了匹配CNN的输入

[python]  view plain  copy

1. # Create a convolution + maxpool layer for each filter size  
2.        pooled_outputs = []  
3.        for i, filter_size in enumerate(filter_sizes):  
4.            with tf.name_scope("conv-maxpool-%s" % filter_size):  
5.                # Convolution Layer  
6.                filter_shape = [filter_size, embedding_size, 1, num_filters]  
7.                W = tf.Variable(tf.truncated_normal(filter_shape, stddev=0.1), name="W")  
8.                b = tf.Variable(tf.constant(0.1, shape=[num_filters]), name="b")  
9.                conv = tf.nn.conv2d(  
10.                    self.embedded_chars_expanded,  
11.                    W,  
12.                    strides=[1, 1, 1, 1],  
13.                    padding="VALID",  
14.                    name="conv")  
15.                # Apply nonlinearity  
16.                h = tf.nn.relu(tf.nn.bias_add(conv, b), name="relu")  
17.                # Maxpooling over the outputs  
18.                pooled = tf.nn.max_pool(  
19.                    h,  
20.                    ksize=[1, sequence_length - filter_size + 1, 1, 1],  
21.                    strides=[1, 1, 1, 1],  
22.                    padding='VALID',  
23.                    name="pool")  
24.                pooled_outputs.append(pooled)  

建立了一个pooled_outputs来保存每次卷积结果，在不同的卷积核大小进行卷积、relu激活函数和max_pool的操作后得到pooled，需要注意的是这里的几个设置，池化和卷积中的padding和strides，这里设置的池化和卷积保证了每段文本输出为num_filters*len(filters_sizes)个数字。

[python]  view plain  copy

1. # Combine all the pooled features  
2. num_filters_total = num_filters * len(filter_sizes)  
3. self.h_pool = tf.concat(3, pooled_outputs)  
4. self.h_pool_flat = tf.reshape(self.h_pool, [-1, num_filters_total])  
5.   
6. # Add dropout  
7. with tf.name_scope("dropout"):  
8.     self.h_drop = tf.nn.dropout(self.h_pool_flat, self.dropout_keep_prob)  
9.   
10. # Final (unnormalized) scores and predictions  
11. with tf.name_scope("output"):  
12.     W = tf.get_variable(  
13.         "W",  
14.         shape=[num_filters_total, num_classes],  
15.         initializer=tf.contrib.layers.xavier_initializer())  
16.     b = tf.Variable(tf.constant(0.1, shape=[num_classes]), name="b")  
17.     l2_loss += tf.nn.l2_loss(W)  
18.     l2_loss += tf.nn.l2_loss(b)  
19.     self.scores = tf.nn.xw_plus_b(self.h_drop, W, b, name="scores")  
20.     self.predictions = tf.argmax(self.scores, 1, name="predictions")  
21.       
22.     #Android Tensorflow lib cant handle 64 bit integers, adding an extra output layer  
23.     #with int32 type  
24.     self.predictions32 = tf.to_int32(self.predictions, name="predictions32")  

然后将pooled_outputs中的值全部取出来然后reshape成[len(input_x),num_filters*len(filters_size)]，然后进行了dropout层防止过拟合，最后再添加了一层全连接层与softmax层将特征映射成不同类别上的概率

[python]  view plain  copy

1. # CalculateMean cross-entropy loss  
2. with tf.name_scope("loss"):  
3.     losses = tf.nn.softmax_cross_entropy_with_logits(self.scores, self.input_y)  
4.     self.loss = tf.reduce_mean(losses) + l2_reg_lambda * l2_loss  
5.   
6. # Accuracy  
7. with tf.name_scope("accuracy"):  
8.     correct_predictions = tf.equal(self.predictions, tf.argmax(self.input_y, 1))  
9.     self.accuracy = tf.reduce_mean(tf.cast(correct_predictions, "float"), name="accuracy")  

损失函数使用的交叉熵加上L2正则损失，准确度用的非常多就不特别说明了