NLP基础学习8--TextCNN

终于到了卷积神经网络，这一次的任务是：

1. 卷积运算的定义、动机（稀疏权重、参数共享、等变表示）。一维卷积运算和二维卷积运算。
2. 反卷积(tf.nn.conv2d_transpose)
3. 池化运算的定义、种类（最大池化、平均池化等）、动机。
4. Text-CNN的原理。
5. 利用Text-CNN模型来进行文本分类

卷积

卷积在信号处理中是一个基本的运算，它的基本定义为：
$(f\ast g)(x)={\int }_{-\infty }^{\infty }f(\tau )g(x-\tau )d\tau$
在深度学习中，我们更多的用到的是其离散形式，即：
$(f\ast g)(n)={\sum }_{-\infty }^{\infty }f(\tau )g(n-\tau )$

上面定义的是一维卷积，在图像处理中，因为图像为一个两维结构，所以通常需要将一维卷积进行扩展。给定一个图像$X\in R^{M\times N}$，和滤波器$W\in R^{m\times n}$，一般
m << M, n << N，其卷积为:$$\sum _{u=1}^m\sum _{v=1}^n{w}_{uv}\cdot x_{i-u+1,j-v+1}$$
其具体操作如下：

在图像处理中，卷积经常作为特征提取的有效方法。一幅图像在经过卷积
操作后得到结果称为特征映射（Feature Map）。
从动机出发，卷积网络主要是为了降低权值参数，归纳来看：
降低网络权重数量－局部连接（方法一）

1. 视觉系统局部感受野

• 视觉生理学相关研究普遍认为：人对外界的认知是从局部到全局的。
• 图像空间相关性： 对图像而言，局部邻域内的像素联系较紧密，距离较远的像素相关性则较弱。

2. 神经网络由全连接变为部分连接

• 每个神经元没必要对全局图像进行感知，只需要对局部进行感知

3. 降低网络权重数量－权值共享（方法二）

• 局部连接可降低网络的权重数量，但仍不足够。
• 引入权值共享机制：“将图像任何一个局部区域的数据进行连接时，其权重保持不变”。
  –采用滤波器（卷积核）的术语，可更清晰地描述这一机制。
  1）采用滤波器对图像进行卷积滤波，并将结果输出至隐含层对应的结点。
  2）滤波器是由一组待学习的权重所组成。
• 每个滤波器对应一特征学习。

反卷积

反卷积，它有这几个比较熟悉的名字，例如转置卷积、上采样、空洞卷积、微步卷积，但我们认为，最直接的就是反卷积=上采样=（转置卷积+微步卷积）⊆ 空洞卷积=一般意义上的广义卷积（包含上采样和下采样）。

另外，在概念上，我们只是将其称为反卷积，这不是通过数学意义上的严格证明，其实只是说恢复了特征图的尺寸大小，数值上存在差异。

反卷积的直观解释：

池化

池化层的输入一般来源于上一个卷积层，主要的作用是提供了很强的鲁棒性。（例如max-pooling是取一小块区域中的最大值，此时若此区域中的其他值略有变化，或者图像稍有平移，pooling后的结果仍不变），并且减少了参数的数量，防止过拟合现象的发生。池化层一般没有参数，所以反向传播的时候，只需对输入参数求导，不需要进行权值更新。常见的两种池化 为max-pooling （最主流）和 mean pooling。
对于池化 (聚合、Pooling)，归纳来说：

1. 降低数据维度，避免过拟合
2. 增大局部感受野范围，利于抽象特征的提取
3. 提高平移不变性

TextCNN

Yoon Kim在论文[1]提出TextCNN，将卷积神经网络CNN应用到文本分类任务，利用多个不同size的kernel来提取句子中的关键信息（类似于多窗口大小的ngram），从而能够更好地捕捉局部相关性。其结构如图所示：

实例

惯例贴核心模型代码:

import tensorflow as tf
import numpy as np


class TextCNN(object):
    """
    A CNN for text classification.
    Uses an embedding layer, followed by a convolutional, max-pooling and softmax layer.
    """
    def __init__(
      self, sequence_length, num_classes, vocab_size,
      embedding_size, filter_sizes, num_filters, l2_reg_lambda=0.0):

        # Placeholders for input, output and dropout
        self.input_x = tf.placeholder(tf.int32, [None, sequence_length], name="input_x")
        self.input_y = tf.placeholder(tf.float32, [None, num_classes], name="input_y")
        self.dropout_keep_prob = tf.placeholder(tf.float32, name="dropout_keep_prob")

        # Keeping track of l2 regularization loss (optional)
        l2_loss = tf.constant(0.0)

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

        # 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(pooled_outputs, 3)
        self.h_pool_flat = tf.reshape(self.h_pool, [-1, num_filters_total])

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

        # 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")

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

        # 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")

参考文献

1. 影醉阏轩窗，深度理解反卷积操作，简书（https://www.jianshu.com/p/fb50fe44a1a3）
2. Kim Y. Convolutional neural networks for sentence classification[J]. arXiv preprint arXiv:1408.5882, EMNLP 2014.