Deep MNIST for Experts解读（二）：卷积与最大池化

Deep MNIST for Experts解读（二）：卷积与池化
https://www.tensorflow.org/get_started/mnist/pros


下面看看那三个遗留问题。


1.卷积
conv2d
max_pool_2x2
Tensorflow提供了两个卷积函数，tf.nn.conv2d和tf.nn.conv3d，并不适合拿来直接演示说明基本概念。
什么是卷积运算？
卷积的感性说明：https://www.zhihu.com/question/22298352
卷积的理性说明：http://blog.csdn.net/anan1205/article/details/12313593。
最直观的说明：http://ufldl.stanford.edu/wiki/index.php/%E5%8D%B7%E7%A7%AF%E7%89%B9%E5%BE%81%E6%8F%90%E5%8F%96 
的卷积的那个动图。
这里说明一下。
绿色矩阵为学习样本，橙色是一个小矩阵，称为卷积核，可以把它视为一个滑窗。用卷积核去覆盖样本矩阵，运算一次，得到一个值。
比如： 被卷积核第一次覆盖的子矩阵(绿色)是
[[1,1,1],
 [0,1,1],
 [0,0,1]],
卷积核(橙色)是：
[[1,0,1],
 [0,1,0],
 [1,0,1]]
对应坐标的值相乘，再各元素相加：
1*1+1*0+1*1+0*0+1*1+1*0+0*1+0*0+1*1=4，得到粉红色矩阵的第一个元素。
移动卷积核，依次得到粉红色矩阵的各个元素，这就是卷积运算。
下面来理解下mnist_deep.py中的conv2d。
def conv2d(x, W):
  """conv2d returns a 2d convolution layer with full stride."""
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
tf.nn.conv2d给了四个参数：
x:即输入input，格式为：[训练时一个batch的图片数量, 图片高度, 图片宽度, 输入通道数],
[batch, in_height, in_width, in_channels]
源码中的定义为：x_image = tf.reshape(x, [-1, 28, 28, 1])，也就是batch待定，图片是28*28的，入通道数1，这里指单色的，还有一种是三原色的。
W:即卷积核，又名filter,格式为：[卷积核的高度，卷积核的宽度，输入通道数，输出通道数]
[filter_height, filter_width, in_channels, out_channels]
比如卷积层一的W： W_conv1 = weight_variable([5, 5, 1, 32])，卷积核是5*5，入通道数1，出通道数32.
strides=[1, 1, 1, 1]:x不是一个4维矩阵吗，这四个1是对这4维的滑动步长定义。
padding='SAME':把x的周围补0，尽量左右一样多，搞不定的话让右边多一点0。为什么要被0呢。比如stanford的那个例子，图片是5*5，卷积核是3*3,输出是3*3,但如果想要输出与图片的shape(5*5)一样呢，只有把原图片周围补0了。
做点小练习：参见：http://www.cnblogs.com/lovephysics/p/7220111.html
练习一：
import tensorflow as tf
k = tf.constant([
    [1, 0, 1],
    [2, 1, 0],
    [0, 0, 1]
], dtype=tf.float32, name='k')
i = tf.constant([
    [4, 3, 1, 0],
    [2, 1, 0, 1],
    [1, 2, 4, 1],
    [3, 1, 0, 2]
], dtype=tf.float32, name='i')
kernel = tf.reshape(k, [3, 3, 1, 1], name='kernel')
image  = tf.reshape(i, [1, 4, 4, 1], name='image')


res = tf.squeeze(tf.nn.conv2d(image, kernel, [1, 1, 1, 1], "VALID"))
# VALID means no padding
with tf.Session() as sess:
   print(sess.run(res))
输出：
[[ 14.   6.]
 [  6.  12.]]
14 = 4 * 1 + 3 * 0 + 1 * 1 + 2 * 2 + 1 * 1 + 0 * 0 + 1 * 0 + 2 * 0 + 4 * 1
6 = 3 * 1 + 1 * 0 + 0 * 1 + 1 * 2 + 0 * 1 + 1 * 0 + 2 * 0 + 4 * 0 + 1 * 1
6 = 2 * 1 + 1 * 0 + 0 * 1 + 1 * 2 + 2 * 1 + 4 * 0 + 3 * 0 + 1 * 0 + 0 * 1
12 = 1 * 1 + 0 * 0 + 1 * 1 + 2 * 2 + 4 * 1 + 1 * 0 + 1 * 0 + 0 * 0 + 2 * 1
练习二：
input = tf.Variable(tf.random_normal([1,5,5,5]))  
filter = tf.Variable(tf.random_normal([3,3,5,1]))  
op = tf.nn.conv2d(input, filter, strides=[1, 1, 1, 1], padding='VALID')  
sess=tf.Session()
init=tf.global_variables_initializer()
sess.run(init)
print(op)
print(sess.run(op))
输出：
Tensor("Conv2D:0", shape=(1, 3, 3, 1), dtype=float32)
[[[[ -3.14853334]
   [ 16.14700508]
   [ -6.45538139]]


  [[  0.56099153]
   [ -1.47099018]
   [ -4.1546545 ]]


  [[ -5.06771278]
   [  1.38102365]
   [  6.75113153]]]]
shape=(1, 3, 3, 1)是什么含义呢，返回格式未指明的话，指"NHWC"，[batch, height, width, channels].（N记为next_batch？好记就先这样记）
可见得到一个3*3的矩阵。VALID，周边没加0嘛。
练习三：同上，把VALID改为SAME。
Tensor("Conv2D:0", shape=(1, 5, 5, 1), dtype=float32)
[[[[  5.71891451]
   [ -2.38102531]
   [ -1.01240289]
   [ -8.67125034]
   [ -0.13419724]]


  [[ -5.37069035]
   [ 16.43548012]
   [  9.87151146]
   [ -1.95723248]
   [ -8.0474062 ]]


  [[ -4.77947903]
   [  9.48705101]
   [  1.43431211]
   [ -4.63299465]
   [  0.04765606]]


  [[  1.12986112]
   [ -6.85580826]
   [  1.7185322 ]
   [ -0.11351717]
   [  1.80565023]]
得到的输出和input的shape是一样的，5*5，计算时input周边补了0.
练习四：输出通道改为7.其它略
input = tf.Variable(tf.random_normal([1,5,5,5]))  
filter = tf.Variable(tf.random_normal([3,3,5,7]))  
输出：Tensor("Conv2D:0", shape=(1, 5, 5, 7), dtype=float32)


2.池化（最大池化）
卷积的问题到这里就差不多了。下面说下池化。
还是先说基本概念
说个比较形象的例子，参见http://m.blog.csdn.net/sinat_32547403/article/details/74937389的图。
第一步不是得到了卷积吗，把这个卷积矩阵划分为一个个小豆腐块，把这个小块中的最大值摘出来，形成一个由最大值元素组成的矩阵，就是最大池化操作。好理解吧。
再看看源码：
def max_pool_2x2(x):
  """max_pool_2x2 downsamples a feature map by 2X."""
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                        strides=[1, 2, 2, 1], padding='SAME')
max_pool仍然四个参数：
x:即value，表现为[batch, height, width, channels]，和conv2d的x参数类似。
ksize=[1, 2, 2, 1]：对x的四个维度，指定窗口大小。本例第二、三维是2，也就是把x中的矩阵划为2*2的豆腐块，再选最大值。
strides=[1, 2, 2, 1]：对x的四个维度，指定滑动大小。由于每块豆腐块不重叠，所以第二、三个参数也是2和2。
padding='SAME'：补0，同上。
作为练习：
x = tf.Variable(tf.random_normal([1,6,6,1]))  
op = tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                        strides=[1, 2, 2, 1], padding='SAME')
sess=tf.Session()
init=tf.global_variables_initializer()
sess.run(init)
print('x::', sess.run(x))
print('op::',sess.run(op))
输出x，为了查看上去方便，格式作了下整理:
[[[[ 0.64246583]   [ 0.91550928]   [ 0.8078894 ]   [ 0.2527563 ]   [ 0.16877377]   [ 0.75468737]]
  [[ 1.88294566]   [-0.27354711]   [ 0.891653  ]   [-0.28982827]   [-0.04847682]   [ 1.0516088 ]]
  [[-0.37016639]   [-0.91406488]   [ 0.23838577]   [-0.78308594]   [ 0.58814621]   [ 0.35315144]]
  [[ 0.73015124]   [-1.58307457]   [-0.23730309]   [-0.1681792 ]   [-0.41411981]   [ 0.57433921]]
  [[ 0.25227892]   [ 0.76516557]   [ 0.40843379]   [ 0.43834141]   [ 0.29453221]   [-0.43508232]]
  [[-0.78055584]   [ 0.12396565]   [-0.71946895]   [-0.48513463]   [ 1.21338081]   [-0.9063347 ]]]]
输出op，为了查看上去方便，格式作了下整理:
[[[[ 1.88294566]   [ 0.891653  ]   [ 1.0516088 ]]
  [[ 0.73015124]   [ 0.23838577]   [ 0.58814621]]
  [[ 0.76516557]   [ 0.43834141]   [ 1.21338081]]]]
可以看到，tf.nn.max_pool把x分为了3*3个小块，取了每块的最大值，如第一块最大值是1.88294566。


卷积和最大池化是CNN的关键概念。
下节，讲第二个遗留问题，理解deepnn。