肯定能让你看懂——tf.nn.max_pool和tf.nn.conv2d（）

两个参数分别用于二维卷积 和 池化操作

tf.nn.conv2d（）

def conv2d(input,  # 张量输入
			filter, # 卷积核参数
			strides, # 步长参数
			padding, # 卷积方式
			use_cudnn_on_gpu=None, # 是否是gpu加速
            data_format=None,  # 数据格式，与步长参数配合，决定移动方式
            name=None): # 名字，用于tensorboard图形显示时使用

• input必须是一个四维的tensor，以28X28X1的图像为案例进行说明，首先需要转换为4维，需要加入图像样本的个数，假设为100张，变为[100,28,28,1]，直观理解为100张 28X28的只有一个通道的图片。

• filter，即卷积神经网络的滤波器，必须与input维度相同，[3,3,1,2]，通俗理解为3X3的卷积核2个，只作用于1个通道，即input的最后一个参数和filter的倒数第二个参数是相同的。

• stride，控制卷积核的移动步数，与上述两个参数相同，也是四维的，[1,1,1,1]，其中第一个1和最后一个1是固定值，需要改变的是中间的两个数，即在x轴和y轴的移动步长。

• padding，只有两个取值，‘SAME’和’VALID’，第一个是填充边界，第二个是当不足以移动时直接舍弃。

tf.nn.max_pool

tf.nn.max_pool(value, ksize, strides, padding, name=None)

参数是四个，和卷积很类似：

• value：需要池化的输入，一般池化层接在卷积层后面，所以输入通常是feature map，依然是[batch, height, width, channels]这样的shape

• ksize：池化窗口的大小，取一个四维向量，一般是[1, height, width, 1]，因为我们不想在batch和channels上做池化，所以这两个维度设为了1

• strides：和卷积类似，窗口在每一个维度上滑动的步长，一般也是[1, stride,stride, 1]

• padding：和卷积类似，可以取’VALID’ 或者’SAME’

一个例子

一个textcnn的核心

import tensorflow as tf  
tf.reset_default_graph()
  
a=tf.constant([  
        [[1.0,2.0,3.0],  
        [5.0,6.0,7.0],  
        [8.0,7.0,6.0],  
        [4.0,3.0,2.0]],  
        [[4.0,3.0,2.0],  
         [8.0,7.0,6.0],  
         [1.0,2.0,3.0],  
         [5.0,6.0,7.0]]  
    ])  
a=tf.reshape(a,[1,4,6,1])
print(a.shape)
#  代表着batch为1  有4个单词  每个单词映射到6维的embedding channel等于1
W = tf.Variable(tf.truncated_normal([1,6,1,2], stddev=0.1))
conv = tf.nn.conv2d(a, # input必须是一个四维的tensor [batch_size, sequence_length, embedding_size, 1] 
                        #直观理解为batch_size张 sequence_length X embedding_size的只有一个通道的图片
                        W,              # [卷积的高度, 卷积的宽度,  in_channels, out_channels]
                        strides=[1, 1, 1, 1],#[batch, height, width, channels] ,只需要中间的步长[1, height, width, 1]
                        padding='VALID')

# 这个卷积 是对每一行的单词 卷积出来一个结果

pooled = tf.nn.max_pool(conv, #[batch, height, width, channels]
                        ksize=[1,4,1, 1], # 取一个四维向量，一般是[1, height, width, 1]，
                        #因为我们不想在batch和channels上做池化，所以这两个维度设为了1
                        strides=[1, 1, 1, 1],
                        padding='VALID')
# 对这个句子（四个单词组成）进行最大池化 选取做大特征
#pooling=tf.nn.max_pool(a,[1,2,2,1],[1,1,1,1],padding='VALID')  
with tf.Session() as sess:  
    sess.run( tf.global_variables_initializer() )
    print("text:")
    image=sess.run(a)  
    print (image)  
    print (image.shape)  
    print("Conv:")
    conv = sess.run(conv)  
    print(conv)  
    print(conv.shape)  
    print("Pooled:")  
    pl=sess.run(pooled)  
    print(pl)  
    print(pl.shape) 

# 结果：
(1, 4, 6, 1)
text:
[[[[1.]
   [2.]
   [3.]
   [5.]
   [6.]
   [7.]]

  [[8.]
   [7.]
   [6.]
   [4.]
   [3.]
   [2.]]

  [[4.]
   [3.]
   [2.]
   [8.]
   [7.]
   [6.]]

  [[1.]
   [2.]
   [3.]
   [5.]
   [6.]
   [7.]]]]
(1, 4, 6, 1)
Conv:
[[[[-0.07554889 -0.40086278]]

  [[ 0.02359521  0.00971377]]

  [[ 0.01624271 -0.8424387 ]]

  [[-0.07554889 -0.40086278]]]]
(1, 4, 1, 2)
Pooled:
[[[[0.02359521 0.00971377]]]]
(1, 1, 1, 2)