nn.AvgPool2d——二维平均池化操作

PyTorch学习笔记：nn.AvgPool2d——二维平均池化操作

torch.nn.AvgPool2d( kernel_size , stride=None , padding=0 , ceil_mode=False , count_include_pad=True , divisor_override=None )
1

功能：在由多个平面组成的输入信号上应用2D平均池化操作，具体计算公式如下：
$$\begin{gathered} out(N_i,C_i,h,w)=\frac{1}{kH\ast kW}\sum _{m=0}^{kH-1}\sum _{m=0}^{kH-1}input(N_i,C_i,stride[0]\times h+m,stride[1]\times w+n) \\ 假设输入尺寸是(N,C,H,W),输出尺寸是(N,C,H_{out},W_{out}),池化核尺寸是(kH,kW) \end{gathered}$$
如果padding非零，则会在输入图像的四周隐式地填充0，可以通过指定参数count_include_pad来确定是否将该0纳入池化计算过程。

输入：

• kernel_size：池化核的尺寸大小
• stride：窗口的移动步幅，默认与kernel_size大小一致
• padding：在两侧的零填充宽度大小
• ceil_mode：设为True时，在计算输出形状的过程中采用向上取整的操作，否则，采用向下取整
• count_include_pad：布尔类型，当为True时，将在平均池化计算中包括零填充，否则，不包括零填充
• divisor_override：如果被指定，则除数会被代替成divisor_override。换句话说，如果不指定该变量，则平均池化的计算过程其实是在一个池化核内，将元素相加再除以池化核的大小，也就是divisor_override默认为池化核的高×宽；如果该变量被指定，则池化过程为将池化核内元素相加再除以divisor_override。

注意：

• 参数的kernel_size、stride、padding可以是：

  • 整数，这种情况下，高和宽尺寸相同
  • 元组，包含两个整数，第一个用于高度维度，第二个用于宽度维度

• 输出形状的计算公式为：
  $$\begin{gathered} H_{out}=\lfloor \frac{H_{in}+2\times padding[0]-kernel\_size[0]}{stride[0]}+1\rfloor \\ {W}_{out}=\lfloor \frac{W_{in}+2\times padding[1]-kernel\_size[1]}{stride[1]}+1\rfloor \\ 其中，H_{in}和W_{in}为输入的高和宽，默认向下取整(可指定参数来修改取整规则) \end{gathered}$$

• padding大小要小于池化核的尺寸大小

代码案例

一般用法

import torch
from torch import nn
img=torch.arange(16).reshape(1,1,4,4)
# 池化核和池化步长均为2
pool=nn.AvgPool2d(2,stride=2)
img_2=pool(img)
print(img)
print(img_2)
1
2
3
4
5
6
7
8

输出

# 原图像
tensor([[[[ 0,  1,  2,  3],
          [ 4,  5,  6,  7],
          [ 8,  9, 10, 11],
          [12, 13, 14, 15]]]])
# 池化后图像，长宽均为原来的一半
tensor([[[[ 2,  4],
          [10, 12]]]])
1
2
3
4
5
6
7
8

ceil_mode设为True与Fasle的区别

import torch
from torch import nn
img=torch.arange(20,dtype=torch.float).reshape(1,1,4,5)
pool_f=nn.AvgPool2d(2,stride=2,padding=0,ceil_mode=False)
pool_t=nn.AvgPool2d(2,stride=2,padding=0,ceil_mode=True)
img_2=pool_f(img)
img_3=pool_t(img)
print(img)
print(img_2)
print(img_3)
1
2
3
4
5
6
7
8
9
10

输出

# 原图像
tensor([[[[ 0.,  1.,  2.,  3.,  4.],
          [ 5.,  6.,  7.,  8.,  9.],
          [10., 11., 12., 13., 14.],
          [15., 16., 17., 18., 19.]]]])
# 默认情况，ceil_mode为False
tensor([[[[ 3.,  5.],
          [13., 15.]]]])
# ceil_mode为True
tensor([[[[ 3.0000,  5.0000,  6.5000],
          [13.0000, 15.0000, 16.5000]]]])
# 由于5不能被2整除，所以一个下取整，一个上取整
1
2
3
4
5
6
7
8
9
10
11
12

padding设与不设的区别

import torch
from torch import nn
img=torch.arange(16,dtype=torch.float).reshape(1,1,4,4)
pool_t=nn.AvgPool2d(2,stride=2,padding=1)
pool_f=nn.AvgPool2d(2,stride=2)
img_2=pool_t(img)
img_3=pool_f(img)
print(img)
print(img_2)
print(img_3)
1
2
3
4
5
6
7
8
9
10

输出

# 原图
tensor([[[[ 0.,  1.,  2.,  3.],
          [ 4.,  5.,  6.,  7.],
          [ 8.,  9., 10., 11.],
          [12., 13., 14., 15.]]]])
# 填充宽度为1，默认填充的0会被用于池化计算
tensor([[[[0.0000, 0.7500, 0.7500],
          [3.0000, 7.5000, 4.5000],
          [3.0000, 6.7500, 3.7500]]]])
# 未填充结果
tensor([[[[ 2.5000,  4.5000],
          [10.5000, 12.5000]]]])
# 填充后的图像经过池化运算得到的图像尺寸可以用上面的公式计算出来
1
2
3
4
5
6
7
8
9
10
11
12
13

count_include_pad设为True与False的区别

import torch
from torch import nn
img=torch.arange(16,dtype=torch.float).reshape(1,1,4,4)
pool_t=nn.AvgPool2d(2,stride=2,padding=1,count_include_pad=True)
pool_f=nn.AvgPool2d(2,stride=2,padding=1,count_include_pad=False)
img_2=pool_t(img)
img_3=pool_f(img)
print(img)
print(img_2)
print(img_3)
1
2
3
4
5
6
7
8
9
10

输出

# 原图
tensor([[[[ 0.,  1.,  2.,  3.],
          [ 4.,  5.,  6.,  7.],
          [ 8.,  9., 10., 11.],
          [12., 13., 14., 15.]]]])
# 填充宽度为1，count_include_pad为True(默认情况)
# 填充的0被用于池化计算
tensor([[[[0.0000, 0.7500, 0.7500],
          [3.0000, 7.5000, 4.5000],
          [3.0000, 6.7500, 3.7500]]]])
# 填充的0未被用于池化计算
tensor([[[[ 0.0000,  1.5000,  3.0000],
          [ 6.0000,  7.5000,  9.0000],
          [12.0000, 13.5000, 15.0000]]]])
1
2
3
4
5
6
7
8
9
10
11
12
13
14

divisor_override设与未设的区别

import torch
from torch import nn
img=torch.arange(16,dtype=torch.float).reshape(1,1,4,4)
pool_1=nn.AvgPool2d(2,stride=2)
pool_d1=nn.AvgPool2d(2,stride=2,divisor_override=2)
pool_d2=nn.AvgPool2d(2,stride=2,divisor_override=3)
img_1=pool_1(img)
img_2=pool_d1(img)
img_3=pool_d2(img)
print(img)
print(img_1)
print(img_2)
print(img_3)
1
2
3
4
5
6
7
8
9
10
11
12
13

输出

# 原图像
tensor([[[[ 0.,  1.,  2.,  3.],
          [ 4.,  5.,  6.,  7.],
          [ 8.,  9., 10., 11.],
          [12., 13., 14., 15.]]]])
# 未设置divisor_override，此时是普通的平均池化操作
tensor([[[[ 2.5000,  4.5000],
          [10.5000, 12.5000]]]])
# divisor_override设置为2，以左上角四个元素为例
# 池化后第一个元素为原图左上角四个元素相加除以2
tensor([[[[ 5.,  9.],
          [21., 25.]]]])
# divisor_override设置为3,
# 即四个元素相加除以3
tensor([[[[ 3.3333,  6.0000],
          [14.0000, 16.6667]]]])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

官方文档

torch.nn.AvgPool2d()：https://pytorch.org/docs/stable/generated/torch.nn.AvgPool2d.html?highlight=avgpool2d#torch.nn.AvgPool2d