tf.nn.max_pool(
    value,
    ksize,
    strides,
    padding,
    data_format='NHWC',
    name=None
)
 
实现最大池化
 value： 4维张量，维度顺序参考data_format
 ksize: value中，对应维度的池化框的大小，一般为[1,f,f,1]
 strides: 步长，对应维度的步长，一般为[1,s,s,1]
 padding：填充方式，一般为‘SAME’或者‘VALID’，string格式
 data_format: 数据导入格式，默认为[个数，高度，宽度，信道数]
 
输出，对应池化后的张量
 
参考：
 https://tensorflow.google.cn/api_docs/python/tf/nn/max_pool

 1. 池化(Pooling)概念
 
 在神经网络中，池化函数(Pooling Function)一般在卷积函数的下一层。在经过卷积层提取特征之后，得到的特征图代表了  比  像素   更高级的特征，已经可以交给 分类器 进行训练分类了。但是我们 每一组卷积核  都生成 一副与原图像素相同大小的  卷积图，节点数一点没少。如果使用了 多个卷积核  还会使得通道数比之前多的多！我靠，这维度不一下子上去了嘛。所以卷积之后我们需要进行池化，也就是进行降维。
 
 
 
 
 池化操作是利用一个矩阵窗口在张量上进行扫描，将每个矩阵中的通过取最大值或者平均值等来减少元素的个数（备注：最大值和平均值的方法可以使得特征提取拥有“平移不变性”，也就说图像有了几个像素的位移情况下，依然可以获得稳定的特征组合，平移不变形对于识别十分重要）。
 
 池化的过程：如下图所示(左边红色区域里边的数据分别为2 2 2 4，有点不清晰)，kernel size 就是矩阵窗口大小，Stides 就是移动的步长。
 
 Max Pooling就找每个矩阵窗口中的最大值；
 
 Mean Pooling就是对每个矩阵窗口中取平均值；
 
 Stochastic Pooling详解见http://www.cnblogs.com/tornadomeet/p/3432093.html
 
 
 
 
 其他的地方和卷积相似：
 
 
 
 
 
 
  
 
   [python] view plain copy 
   
 
    
   
 
    print?
  
 
 
 
 
 pool = tf.nn.max_pool(conv, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')  
 
 

背景
 
在CNN中，池化函数一般放在卷积层之后，图片经过卷积层，获得的特征更加适合分类器的学习，然而如果进行的是同卷积或者全卷积，得到的特征大小不比原来的小，这样我们就需要降维，为此引入池化函数。
 
池化函数tf.nn.max_pool(avg_pool)
 
在TensorFlow中池化函数如下：
 tf.nn.max_pool(input,ksize,strides,padding,name=None)
 tf.nn.avg_pool(input,ksize,strides,padding,name=None)
 说明：
 input:需要池化的输入，一般池化层接在卷积层之后，所以通常输入的是feature map，依然是[batch,height,width,channels]这样的shape
 ksize:池化窗口的大小，取一个四维向量，一般是[1,height,width,1]，因为我们不想在batch和channels上做池化，所以这两个维度设为1.
 strides:和卷积参数含义一样，窗口在每个维度上滑动的步长，一般也是[1,stride,stride,1].
 padding:和卷积参数含义一样，也是取VALID或者SAME，VALID是不padding操作，SAME是padding操作。
 
实例：池化函数的使用
 
1.定义输入变量
 定义1个输入变量用来模拟输入图片，4×4大小的2通道矩阵，并将其赋予指向的值。2个通道分别为：4个0到4个3组成的矩阵，4个4到4个7组成的矩阵。
 
 import tensorflow as tf
img = tf.constant([[[0.0,4.0],[0.0,4.0],[0.0,4.0],[0.0,4.0]],
                   [[1.0,5.0],[1.0,5.0],[1.0,5.0],[1.0,5.0]],
                   [[2.0,6.0],[2.0,6.0],[2.0,6.0],[2.0,6.0]],
                   [[3.0,7.0],[3.0,7.0],[3.0,7.0],[3.0,7.0]]])
img = tf.reshape(img,shape=[1,4,4,2])
 
2.定义池化操作
 这里定义了4个池化操作和一个取均值操作。前两个操作是最大池化操作，接下来两个是均值池化操作，最后一个是取均值操作。
 
pooling = tf.nn.max_pool(img,[1,2,2,1],[1,2,2,1],padding='VALID')
pooling1 = tf.nn.max_pool(img,[1,2,2,1],[1,1,1,1],padding='VALID')
pooling2 = tf.nn.avg_pool(img,[1,4,4,1],[1,1,1,1],padding='SAME')
pooling3 = tf.nn.avg_pool(img,[1,4,4,1],[1,4,4,1],padding='SAME')
nt_hpool2_flat = tf.reshape(tf.transpose(img),[-1,16])
pooling4 = tf.reduce_mean(nt_hpool2_flat,1)#1表示对行求均值（轴是行），0表示对列求均值
 
3.运行池化操作
 
with tf.Session() as sess:
    # tf.global_variables_initializer()
    sess.run(tf.global_variables_initializer())
    print("image:")
    images = sess.run(img)
    print(images)
    result=sess.run(pooling)
    print("result:\n",result)
    result = sess.run(pooling1)
    print("result1:\n",result)
    result = sess.run(pooling2)
    print("result2:\n", result)
    result = sess.run(pooling3)
    print("result3:\n", result)
    flat,result = sess.run([nt_hpool2_flat,pooling4])
    print("result4:\n",result)
    print("flat:\n",flat)
 
结果：
 
 
image：
 [[[[0. 4.]
 [0. 4.]
 [0. 4.]
 [0. 4.]]
 
[[1. 5.]
 [1. 5.]
 [1. 5.]
 [1. 5.]]
 
[[2. 6.]
 [2. 6.]
 [2. 6.]
 [2. 6.]]
 
[[3. 7.]
 [3. 7.]
 [3. 7.]
 [3. 7.]]]]
 通过上面的输出可以看出，img与我们设置的初始值是一样的，即第一个通道为
 [[0 0 0 0],
 [1 1 1 1],
 [2 2 2 2],
 [3 3 3 3]]
 第二个通道为
 [[4 4 4 4],
 [5 5 5 5],
 [6 6 6 6],
 [7 7 7 7]]。
 
 
result:
 [[[[1. 5.]
 [1. 5.]]
 
[[3. 7.]
 [3. 7.]]]]
 这个操作在卷积神经网络中是最常用的，一般步长都会设成与池化滤波器尺寸一致（池化的卷积尺寸为2×2，所以步长为2），生成2个通道的2×2矩阵。矩阵的内容是从原始输入中取最大值，由于池化filter中对应的通道维度是1，所以结果仍然保持源通道数
 
 
result1:
 [[[[1. 5.]
 [1. 5.]
 [1. 5.]]
 
[[2. 6.]
 [2. 6.]
 [2. 6.]]
 
[[3. 7.]
 [3. 7.]
 [3. 7.]]]]
 
result2:
 [[[[1. 5. ]
 [1. 5. ]
 [1. 5. ]
 [1. 5. ]]
 
[[1.5 5.5]
 [1.5 5.5]
 [1.5 5.5]
 [1.5 5.5]]
 
[[2. 6. ]
 [2. 6. ]
 [2. 6. ]
 [2. 6. ]]
 
[[2.5 6.5]
 [2.5 6.5]
 [2.5 6.5]
 [2.5 6.5]]]]
 result1和result2分别演示了VALID和SAME的两种padding的取值。
 1.VALID中使用的filter为2×2，步长为1×1，生成了2×2大小的矩阵。
 2.在SAME中使用的filter，步长仍然为1×1，生成4×4的矩阵，padding之后在计算avg_pool时，是将输入矩阵与filter对应尺寸内的元素总和除以这些元素中非0的个数（而不是filter的总个数）
 
 
result3:
 [[[[1.5 5.5]]]]
 result4:
 [1.5 5.5]
 flat:
 [[0. 1. 2. 3. 0. 1. 2. 3. 0. 1. 2. 3. 0. 1. 2. 3.]
 [4. 5. 6. 7. 4. 5. 6. 7. 4. 5. 6. 7. 4. 5. 6. 7.]]
 
result3是常用的操作手法，也叫全局池化法，就是使用一个与原有输入同样尺寸的filter进行池化，一般放在最后一层，用于表达图像通过卷积网络处理后的最终特征。而result4是一个均值操作 ，可以看到将数据转置后的均值操作得到的值，与全局池化平均值是一样的结果。

最大池化（Max Pooling）
 
网格内的值不取平均值，而是取网格内的最大值进行池化操作。
 
import imageio
import numpy as np
import matplotlib.pylab as plt

img = imageio.imread("imori.jpg")
s = 8
rows,cols,C = img.shape

nrows = int(rows/s)
ncols = int(cols/s)
img1 = np.zeros((nrows,ncols,C),np.uint8)

for row in range(nrows):
    for col in range(ncols):
        for c in range(C):
            img1[row,col,c] = np.max(img[row*s:(row+1)*s-1,col*s:(col+1)*s-1,c])


# imageio.imsave("output.jpg",img1)
plt.figure(figsize=(8,6))
plt.subplot(121)
plt.imshow(img)
plt.axis('off') 
plt.subplot(122)
plt.imshow(img1)
plt.axis('off') 
plt.show()

 
结果：