tf.nn.pool()

最新推荐文章于 2023-08-11 11:01:55 发布

爱抠脚的coder

最新推荐文章于 2023-08-11 11:01:55 发布

阅读量2.8k

点赞数 1

分类专栏： tensorflow 文章标签： tf.nn.pool()

本文链接：https://blog.csdn.net/m0_37393514/article/details/82251332

版权

tensorflow 专栏收录该内容

24 篇文章 4 订阅

订阅专栏

在网上找了很久关于这个函数的解释，都没有找到相关的解释：看了一下官网也没有怎么搞懂，到底是怎么求解的。

自己写了几个最简单的例子，算是解释吧！

一、函数原型

函数的原型：

tf.nn.pool(
    input,
    window_shape,
    pooling_type,
    padding,
    dilation_rate=None,
    strides=None,
    name=None,
    data_format=None
)

参数解释：

input:张量的秩为N+2,这个N是window_shape的长度，默认的情况下，我们的输入的方式是按照[batch_size,input_spatial_shape,num_channels],如果不是默认的方式，也就是按照NC的方式排布的话，我们的input的shape为[batch_size,num_channels,input_spatial_shape]。很显然，池化的操作仅仅在输入的spatial dimensions.

window_shape:由N个int组成的，N大于等于1.

pooling_type:是池化的方式，只有两种AVG或者是MAX

padding:只有两种“SAME”或者是“VALID”，SAME就是和原本的input具有相同的大小，VALID就是正常的操作。

dilation_rate:可选，

strides:可选，

name:可选，

data_format:一个字符串或者为NONE，表示的是input的通道channel是否是输入的最后一个维度。默认是channel是最后的一个维度，如果是第二个维度的话，那么data_format开始于“NC”。

返回的是：秩为N+2的张量，大小是[batch_size,output_spatial_shape,num_channels](如果data_format为None，或者不开始于NC)，反之大小为[batch_size,num_channels,output_sparial_shape].

如果padding=“SAME”，output_spatial_shape[i] = ceil(input_spatial_shape[i] / strides[i])

如果padding=“VALID”，output_spatial_shape[i] = ceil((input_spatial_shape[i] - (window_shape[i] - 1) * dilation_rate[i]) / strides[i]).

二、例子

例子一：

import tensorflow as tf

temp=[0.,0.,1.,0.,0.,0.,1.5,1.5,3.,3.,0.,2.,1.,0.,1.,0.,1.,-1.0]
values=tf.reshape(temp,[2,3,3,1])

p_avg=tf.nn.pool(
    input=values,
    window_shape=[2,1],
    pooling_type='AVG',
    padding='VALID'
)

p_max=tf.nn.pool(input=values,
                 window_shape=[3,3],
                 pooling_type='MAX',
                padding="VALID"
)

with tf.Session() as sess:
    print("values")
    print(sess.run(values))
    print("pool-avg")
    print("shape:",sess.run(tf.shape(p_avg)))
    print(sess.run(p_avg))
    print("pool-max")
    print("shape:",sess.run(tf.shape(p_max)))
    print(sess.run(p_max))

结果：

values
[[[[ 0. ]
   [ 0. ]
   [ 1. ]]

  [[ 0. ]
   [ 0. ]
   [ 0. ]]

  [[ 1.5]
   [ 1.5]
   [ 3. ]]]


 [[[ 3. ]
   [ 0. ]
   [ 2. ]]

  [[ 1. ]
   [ 0. ]
   [ 1. ]]

  [[ 0. ]
   [ 1. ]
   [-1. ]]]]
pool-avg
shape: [2 2 3 1]
[[[[0.  ]
   [0.  ]
   [0.5 ]]

  [[0.75]
   [0.75]
   [1.5 ]]]


 [[[2.  ]
   [0.  ]
   [1.5 ]]

  [[0.5 ]
   [0.5 ]
   [0.  ]]]]
pool-max
shape: [2 1 1 1]
[[[[3.]]]


 [[[3.]]]]

先从shape开始分析吧，我们知道pool仅仅操作于输入的spatial dimension，所以对于该例子来说，仅仅操作于第二维度和第三维度，那么很显然，AVG的时候，[3,3]---经过[2,1]---得到---[2,3]，所以输出的shape为[2,2,3,1].同理，在对MAX的时候，[3,3]---经过[3,3]---得到[1,1],所以最后的shape为[2,1,1,1]。

再来分析为什么得到上面的结果吧，我们可以把第一维度的batch_size先丢掉一边.

例子二：只是将维度增加了，没什么难度，为了更好的理解

import tensorflow as tf

temp=[0.,0.,1.,0.,0.,0.,1.5,1.5,3.,3.,0.,2.,1.,0.,1.,0.,1.,-1.0,0.,1.,0.,2.,0.,-3.,0.,0.,
      2.,0.,0.,0.,2.5,1.5,-3.,-3.,0.,-2.,1.,1.,2.,0.,1.,1.0,0.,1.,0.,2.,0.,3.]
values=tf.reshape(temp,[2,4,3,2])

p_avg=tf.nn.pool(
    input=values,
    window_shape=[2,1],
    pooling_type='AVG',
    padding='VALID'
)

p_max=tf.nn.pool(input=values,
                 window_shape=[3,3],
                 pooling_type='MAX',
                padding="VALID"
)

with tf.Session() as sess:
    print("values")
    print(sess.run(values))
    print("pool-avg")
    print("shape:",sess.run(tf.shape(p_avg)))
    print(sess.run(p_avg))
    print("pool-max")
    print("shape:",sess.run(tf.shape(p_max)))
    print(sess.run(p_max))

结果：

values
[[[[ 0.   0. ]
   [ 1.   0. ]
   [ 0.   0. ]]

  [[ 1.5  1.5]
   [ 3.   3. ]
   [ 0.   2. ]]

  [[ 1.   0. ]
   [ 1.   0. ]
   [ 1.  -1. ]]

  [[ 0.   1. ]
   [ 0.   2. ]
   [ 0.  -3. ]]]


 [[[ 0.   0. ]
   [ 2.   0. ]
   [ 0.   0. ]]

  [[ 2.5  1.5]
   [-3.  -3. ]
   [ 0.  -2. ]]

  [[ 1.   1. ]
   [ 2.   0. ]
   [ 1.   1. ]]

  [[ 0.   1. ]
   [ 0.   2. ]
   [ 0.   3. ]]]]
pool-avg
shape: [2 3 3 2]
[[[[ 0.75  0.75]
   [ 2.    1.5 ]
   [ 0.    1.  ]]

  [[ 1.25  0.75]
   [ 2.    1.5 ]
   [ 0.5   0.5 ]]

  [[ 0.5   0.5 ]
   [ 0.5   1.  ]
   [ 0.5  -2.  ]]]


 [[[ 1.25  0.75]
   [-0.5  -1.5 ]
   [ 0.   -1.  ]]

  [[ 1.75  1.25]
   [-0.5  -1.5 ]
   [ 0.5  -0.5 ]]

  [[ 0.5   1.  ]
   [ 1.    1.  ]
   [ 0.5   2.  ]]]]
pool-max
shape: [2 2 1 2]
[[[[3.  3. ]]

  [[3.  3. ]]]


 [[[2.5 1.5]]

  [[2.5 3. ]]]]

首先还是分析shape，很显然，pool只针对于第二第三维度，所以我们的输入为[4,3]----经过AVG[2,1]---得到的是[3,3],所以最后的结果为[2,3,3,2];对于MAX,我们的输入的大小是[4,3]--经过MAX[3,3]--得到的是[2,1].

接着是分析为什么得到这样的结果，下图仅仅分析了输入的第一个batch的AVG的结果！其他同理。