用cnn做文本分类总结

总体路线 ：1. embeddding layers ===》2.convolutional layer ===》3.max-pooling ===》4.softmax layer.

1.embedded 将每一个词语对应的向量合并成一个矩阵 作用 进行降维 将维度从词的个数降成词向量的维度、建立词语之间的联系 

 

vocab_size:  词典大小

 

embedding_dim: 词向量维度

 

seq_length: 句子长度

 

embedding_look: 查表操作 根据每个词的位置id 去初始化的w中寻找对应id的向量. 得到一个tensor :[batch_size, seq_length, embedding_size] 既 [?, 56, 128], 此处? 表示batch, 即不知道会有多少输入。

with tf.name_scope("embedding"):
    # tf.random_uniform([self.vocab_size, self.embed_size],-1.0,1.0)
    self.Embedding = tf.get_variable("Embedding", shape=[self.vocab_size, self.embed_size],
                                     iniializer=self.initializer)

　　# 1.获取句子中出现的词 向量的集合 embedding 格式[None,sentence_length,embed_size]
　　self.embedded_words = tf.nn.embedding_lookup(self.Embedding, self.input_x)
　　# 扩大为[None,sentence_length,embed_size,1) 满足2d-conv的要求
　　self.sentence_embeddings_expanded = tf.expand_dims(self.embedded_words,
                                                   　　-1)
corpus ===》?*seq ===》 ?*seq_length*word ===>每一个word转换成对应词向量 ======》?*seq_length*vector(embedding_dim)==?*seq_length*embedding_dim ===>

?*seq_length*embedding_dim*1

[[[seq_length*embedding_dim], [seq_length*embedding_dim], [seq_length*embedding_dim]]]...

2.卷积
a.filter 的宽度与词向量等宽，只能进行一维滑动。

filter_size: 卷积核的高度

num_filter：卷积核的宽度 等于 词向量宽度

b.filter卷积后，结果输出为[batch_size, seq_length - filter_size +1,1,num_filter]的向量。

pooled_outputs = []
for i, filter_size in enumerate(self.filter_sizes):
    with tf.variable_scope("convolution-pooling-%s" % filter_size):
        # ====>a.创建 filter
        filter = tf.get_variable("filter-%s" % filter_size, [filter_size, self.embed_size, 1, self.num_filters],
                                 initializer=self.initializer)
        # ====>b.卷积:
        # conv2d===>计算2-D卷积 需要：4-D `input` 和 `filter`
        # Conv.Input: input tensor `[batch, in_height, in_width, in_channels]`
        # a filter tensor  `[filter_height, filter_width, in_channels, out_channels]`
        # Conv.Returns: `Tensor`. 和 `input`一样. 4-D tensor.
        # 维度顺序由`data_format`决定
        # 1)卷积核 conv2d 输出shape: [1,sequence_length-filter_size+1,1,1];
        # 2)*num_filters--->[1,sequence_length-filter_size+1,1, num_filters];
        # 3)*batch_size--->[batch_size,sequence_length-filter_size+1,1,num_filters]
        # 输入数据格式:NHWC:[batch, height, width, channels];
        # 输出:4-D
        # shape:[batch_size,sequence_length - filter_size + 1,1,num_filters]
        conv = tf.nn.conv2d(self.sentence_embeddings_expanded, filter, strides=[1, 1, 1, 1], padding="VALID",
                            name="conv")
        conv = tf.contrib.layers.batch_norm(conv, is_training=self.is_training_flag, scope='cnn_bn_')

        # ====>c. relu
        b = tf.get_variable("b-%s" % filter_size, [self.num_filters])
        h = tf.nn.relu(tf.nn.bias_add(conv, b), "relu")
        # shape:[batch_size,sequence_length - filter_size + 1,1,num_filters].
        # tf.nn.bias_add:adds `bias` to `value` ====>.max-pooling .value:
        # A 4-D `Tensor` with shape `[batch, height, width, channels]

        # ksize: A list of ints that has length >= 4.
        # The size of the window for each dimension of the input tensor.
        # strides: A list of ints that has length >= 4.
        # The stride of the sliding window for each dimension of the input tensor.
        # shape:[batch_size, 1, 1, num_filters]
        # .max_pool:performs the max pooling on the input.
        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)