凡人多烦事01

这个屌丝很懒，什么也没留下！

热门标签

用Tensorflow实现CNN文本分类(详细解释及TextCNN代码解释)_tensorflow cnn labelencoder

作者：凡人多烦事01 | 2024-04-08 10:49:31

踩

tensorflow cnn labelencoder

本文转载自:http://www.dataguru.cn/forum.php?mod=viewthread&tid=637971&extra=page=1&page=1

Ox00: Motivation最近在研究Yoon Kim的一篇经典之作Convolutional Neural Networks for Sentence Classification，这篇文章可以说是cnn模型用于文本分类的开山之作（其实第一个用的不是他，但是Kim提出了几个variants，并有详细的调参）
wildml对这篇paper有一个tensorflow的实现，具体参见here。其实blog已经写的很详细了，但是对于刚入手tensorflow的新人来说代码可能仍存在一些细节不太容易理解，我也是初学，就简单总结下自己的理解，如果对读者有帮助那将是极好的。
Ox01: Start!我主要对TextCNN这个类进行解读，具体代码在这里。

研究别人代码时，时常问自己几个问题，由问题切入，在读的过程中找答案，这种方式我个人认为是最efficient的

1 这个class的主要作用是什么？ TextCNN类搭建了一个最basic的CNN模型，有input layer，convolutional layer，max-pooling layer和最后输出的softmax layer。
但是又因为整个模型是用于文本的(而非CNN的传统处理对象：图像)，因此在cnn的操作上相对应地做了一些小调整：

对于文本任务，输入层自然使用了word embedding来做input data representation。
接下来是卷积层，大家在图像处理中经常看到的卷积核都是正方形的，比如4*4，然后在整张image上沿宽和高逐步移动进行卷积操作。但是nlp中输入的“image”是一个词矩阵，比如n个words，每个word用200维的vector表示的话，这个”image”就是n*200的矩阵，卷积核只在高度上已经滑动，在宽度上和word vector的维度一致（=200），也就是说每次窗口滑动过的位置都是完整的单词，不会将几个单词的一部分“vector”进行卷积，这也保证了word作为语言中最小粒度的合理性。（当然，如果研究的粒度是character-level而不是word-level，需要另外的方式处理）
由于卷积核和word embedding的宽度一致，一个卷积核对于一个sentence，卷积后得到的结果是一个vector， shape=（sentence_len - filter_window + 1, 1），那么，在max-pooling后得到的就是一个Scalar。所以，这点也是和图像卷积的不同之处，需要注意一下。
正是由于max-pooling后只是得到一个scalar，在nlp中，会实施多个filter_window_size（比如3,4,5个words的宽度分别作为卷积的窗口大小），每个window_size又有num_filters个（比如64个）卷积核。一个卷积核得到的只是一个scalar太孤单了，智慧的人们就将相同window_size卷积出来的num_filter个scalar组合在一起，组成这个window_size下的feature_vector。
最后再将所有window_size下的feature_vector也组合成一个single vector，作为最后一层softmax的输入。

重要的事情说三遍：一个卷积核对于一个句子，convolution后得到的是一个vector；max-pooling后，得到的是一个scalar。

如果对上述讲解还有什么不理解的地方，请移步wildml的另一篇 blog ，包教包会。
说了这么多，总结一下这个类的作用就是：搭建一个用于文本数据的CNN模型！
2 一些参数既然TextCNN类是基于YoonKim的思路搭建的，那么我们接下来一个很重要的步骤就是将paper中提到的各种参数设置都整理出来，有一些参数是关于模型的，有一些参数是关于training的，比如epoch等，这类参数就和模型本身无关，以此来确定我们的TextCNN类需要传递哪些参数来初始化。
赶紧把 paper 打开，来仔细找找参数吧。
3.1节Hyperparameters and Training部分讲到一些，还有一部分在Table1中：
关于model

filter windows: [3,4,5]
filter maps: 100 for each filter window
dropout rate: 0.5
l2 constraint: 3
randomly select 10% of training data as dev set(early stopping)
word2vec(google news) as initial input, dim = 300
sentence of length: n, padding where necessary
number of target classes
dataset size
vocabulary size

关于training

mini batch size: 50
shuffuled mini batch
Adadelta update rule: similar results to Adagrad but required fewer epochs
Test method: standard train/test split ot CV

3 Dropout注意事项正则是解决过拟合的问题，在最后一层softmax的时候是full-connected layer，因此容易产生过拟合。
策略就是在：
在训练阶段，对max-pooling layer的输出实行一些dropout，以概率p激活，激活的部分传递给softmax层。
在测试阶段，w已经学好了，但是不能直接用于unseen sentences，要乘以p之后再用，这个阶段没有dropout了全部输出给softmax层。
4 Embedding Layer

1
2
3
4
5
6
7

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

存储全部word vector的矩阵W W初始化时是随机random出来的，也就是paper中的第一种模型CNN-rand
训练过程中并不是每次都会使用全部的vocabulary，而只是产生一个batch（batch中都是sentence，每个sentence标记了出现哪些word(最大长度为sequence_length)，因此batch相当于一个二维列表），这个batch就是input_x。

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

tf.nn.embedding_lookup:查找input_x中所有的ids，获取它们的word vector。batch中的每个sentence的每个word都要查找。所以得到的embedded_chars的shape应该是[None, sequence_length, embedding_size]（1）
但是，输入的word vectors得到之后，下一步就是输入到卷积层，用到tf.nn.conv2d函数，
再看看conv2d的参数列表：
input: [batch, in_height, in_width, in_channels]（2）
filter: [filter_height, filter_width, in_channels, out_channels]（3）
对比（1）（2）可以发现，就差一个in_channels了，而最simple的版本也就只有1通道（Yoon的第四个模型用到了multichannel）
因此需要expand dim来适应conv2d的input要求，万能的tensorflow已经提供了这样的功能：

This operation is useful if you want to add a batch dimension to a single element. For example, if you have a single image of shape [height, width, channels], you can make it a batch of 1 image with expand_dims(image, 0), which will make the shape [1, height, width, channels].
Example:
# ‘t’ is a tensor of shape [2]
shape(expand_dims(t, -1)) ==> [2, 1]

因此只需要

1	tf.expand_dims(self.embedded_chars, -1)

就能在embedded_chars后面加一个in_channels=1
5 Conv and Max-pooling

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# Create a convolution + maxpool layer for each filter size
pooled_outputs = []
for i, filter_size in enumerate(filter_sizes):
with tf.name_scope("conv-maxpool-%s" % filter_size):
      # Convolution Layer
      filter_shape = [filter_size, embedding_size, 1, num_filters]
      W = tf.Variable(tf.truncated_normal(filter_shape, stddev=0.1), name="W")
      b = tf.Variable(tf.constant(0.1, shape=[num_filters]), name="b")
      conv = tf.nn.conv2d(
         self.embedded_chars_expanded,
         W,
         strides=[1, 1, 1, 1],
         padding="VALID",
         name="conv")
      # Apply nonlinearity
      h = tf.nn.relu(tf.nn.bias_add(conv, b), name="relu")
      # Maxpooling over the outputs
      pooled = tf.nn.max_pool(
         h,
         ksize=[1, sequence_length - filter_size + 1, 1, 1],
         strides=[1, 1, 1, 1],
         padding='VALID',
         name="pool")
      pooled_outputs.append(pooled)

# Combine all the pooled features
num_filters_total = num_filters * len(filter_sizes)
self.h_pool = tf.concat(3, pooled_outputs)
self.h_pool_flat = tf.reshape(self.h_pool, [-1, num_filters_total])

首先，对filter_sizes中的每一个filter_window_size都要进行卷积（每一种size都要产生num_filters那么多个filter maps），所以外层就是一个大的for循环。
继续，看到了一个比较陌生的函数tf.name_scope('xxx')
这个函数的作用参见官方文档
由于在for循环内部，filter_size是固定了的，因此可以结合（3）：[filter_height, filter_width, in_channels, out_channels]得到，filter_shape = [filter_size, embedding_size, 1, num_filters]
之所以要弄清楚filter shape是因为要对filter的权重矩阵w进行初始化：

1	W = tf.Variable(tf.truncated_normal(filter_shape, stddev=0.1), name="W")

这里为什么要用tf.truncated_normal()函数呢？
答：tensorflow中提供了两个normal函数：

tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)
tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

对比了一下，这两个函数的参数列表完全相同，不同之处我就直接引用文档中的说明，讲解的很清楚，

Outputs random values from a truncated normal distribution.
The generated values follow a normal distribution with specified mean and standard deviation, except that values whose magnitude is more than 2 standard deviations from the mean are dropped and re-picked.

也就是说random出来的值的范围都在[mean - 2 standard_deviations, mean + 2 standard_deviations]内。
下图可以告诉你这个范围在哪，

conv2d得到的其实是下图中的w⋅x w⋅x的部分，

还要加上bias项tf.nn.bias_add(conv, b)，并且通过relu：tf.nn.relu才最终得到卷积层的输出h h。
那究竟卷积层的输出的shape是什么样呢？
官方文档中有一段话解释了卷积后得到的输出结果：

第三部进行了right-multiply之后得到的结果就是 [batch, out_height, out_width, output_channels]，但是还是不清楚这里的out_height和out_width到底是什么。
那就看看wildml中怎么说的吧

“VALID” padding means that we slide the filter over our sentence without padding the edges, performing a narrow convolution that gives us an output of shape [1, sequence_length - filter_size + 1, 1, 1].

哦，这句话的意思是说out_height和out_width其实和padding的方式有关系，这里选择了”VALID”的方式，也就是不在边缘加padding，得到的out_height=sequence_length - filter_size + 1，out_width=1
因此，综合上面的两个解释，我们知道conv2d-加bias-relu之后得到的h h的shape= [batch, sequence_length - filter_size + 1, 1, num_filters]

接下来的工作就是max-pooling了，来看一下tensorflow中给出的函数:
tf.nn.max_pool(value, ksize, strides, padding, data_format='NHWC', name=None)

其中最重要的两个参数是value和ksize。
value相当于是max pooling层的输入，在整个网络中就是刚才我们得到的h h，check了一下它俩的shape是一致的，说明可以直接传递到下一层。
另一个参数是ksize，官方解释说是input tensor每一维度上的window size。仔细想一下，其实就是想定义多大的范围来进行max-pooling，比如在图像中常见的2*2的小正方形区域对整个h得到feature map进行pooling，但是在nlp中，刚才说到了每一个feature map现在是 [batch, sequence_length - filter_size + 1, 1, num_filters]维度的，我们想知道每个output_channels（每个channel是一个vector）的最大值，也就是最重要的feature是哪一个，那么就是在第二个维度上设定window=sequence_length - filter_size + 1【这里感觉没解释通，待后续探索】
根据ksize的设置，和value的shape，可以得到pooled的shape= [batch, 1, 1, num_filters]，
这是一个filter_size的结果（比如filter_size = 3），pooled存储的是当前filter_size下每个sentence最重要的num_filters个features，结果append到pooled_outputs列表中存起来，再对下一个filter_size进行相同的操作。

等到for循环结束时，也就是所有的filter_size全部进行了卷积和max-pooling之后，首先需要把相同filter_size的所有pooled结果concat起来，再将不同的filter_size之间的结果concat起来，最后的到的应该类似于二维数组，[batch, all_pooled_result]
all_pooled_result一共有num_filters\（100）*len(filter_sizes)（3）个，比如300个
连接的过程需要使用 tf.concat ，官方给出的例子很容易理解。
最后得到的h_pool_flat也就是[batch, 300]维的tensor。
6 Dropout

1
2
3

# Add dropout
with tf.name_scope("dropout"):
self.h_drop = tf.nn.dropout(self.h_pool_flat, self.dropout_keep_prob)

前面在“dropout注意事项”中讲到了，dropout仅对hiddenlayer的输出层进行drop，使得有些结点的值不输出给softmax层。
7 Output

1
2
3
4
5
6
7
8
9
10
11
12

# Final (unnormalized) scores and predictions
with tf.name_scope("output"):
W = tf.get_variable(
      "W",
      shape=[num_filters_total, num_classes],
      initializer=tf.contrib.layers.xavier_initializer())
b = tf.Variable(tf.constant(0.1, shape=[num_classes]), name="b")
l2_loss += tf.nn.l2_loss(W)
l2_loss += tf.nn.l2_loss(b)
self.scores = tf.nn.xw_plus_b(self.h_drop, W, b, name="scores")
self.predictions = tf.argmax(self.scores, 1, name="predictions")

输出层其实是个softmax分类器，没什么可讲的，但是要注意l2正则（虽然有paper说l2加不加并没有什么区别）
但是我还有一个疑问是为什么对b也要进行正则约束？
另外，tf.nn.xw_plus_b()在open api中并没有提供，参考github上的某个 issue
因此可以改为tf.matmul(self.h_drop, W) + b但是不好的地方是无法设置name了。。（用xw_plus_b也不会报错不改也可以）
还有一个奇怪的地方是，这一层按道理说应该是一个softmax layer，但是并没有使用到softmax函数，在Yoon的文章中也是直接得到输出的，

因此，我们也按照这种方式写代码，得到所有类别的score，并且选出最大值的那个类别(argmax)
y的shape为[batch, num_classes]，因此argmax的时候是选取每行的max，dimention=1
因此，最后scores的shape为[batch, 1]
8 Loss function 得到了整个网络的输出之后，也就是我们得到了y_prediction，但还需要和真实的y label进行比较，以此来确定预测好坏。

1
2
3
4

# CalculateMean cross-entropy loss
with tf.name_scope("loss"):
losses = tf.nn.softmax_cross_entropy_with_logits(self.scores, self.input_y)
self.loss = tf.reduce_mean(losses) + l2_reg_lambda * l2_loss

还是使用常规的cross_entropy作为loss function。最后一层是全连接层，为了防止过拟合，最后还要在loss func中加入l2正则项，即l2_loss。l2_reg_lambda来确定惩罚的力度。
9 Accuracy

1
2
3
4

# Accuracy
with tf.name_scope("accuracy"):
correct_predictions = tf.equal(self.predictions, tf.argmax(self.input_y, 1))
self.accuracy = tf.reduce_mean(tf.cast(correct_predictions, "float"), name="accuracy")

tf.equal(x, y)返回的是一个bool tensor，如果xy对应位置的值相等就是true，否则false。得到的tensor是[batch, 1]的。
tf.cast(x, dtype)将bool tensor转化成float类型的tensor，方便计算
tf.reduce_mean()本身输入的就是一个float类型的vector（元素要么是0.0，要么是1.0），直接对这样的vector计算mean得到的就是accuracy，不需要指定reduction_indices
0x02: Conclusion 后续可能还会对其他部分进行解读，敬请期待。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】