【torch.nn : Pooling Layers】

MaxPool2d

CLASS
torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

• 功能： 在由几个输入平面组成的输入信号上应用2D最大池化。

  举个简单的例子： 当输入大小是$(N,C,H,W)$, 输出大小是$(N,C,H_{out},W_{out})$ ，并且卷积核的大小是$(kH,kW)$。输出的大小可以描述为:

  $$\begin{array}{rl}\mathrm{out}\left(N_i,C_j,h,w\right)=& \underset{m=0,\dots ,kH-1}{\max }\underset{n=0,\dots ,kW-1}{\max }\\ & \mathrm{input}\left(N_i,C_j,\mathrm{stride}[0]\times h+m,\text{ stride }[1]\times w+n\right)\end{array}$$

• 注意：

  • 如果padding非零，则输入的两边隐式填充为负无穷大。
  • 参数kernel_size, stride, padding, dilation 可以是如下两种形式：****
    • 一个int :在这种情况下，高度和宽度维度使用相同的值
    • 包含两个int的元组：在这种情况下，第一个int用于表示高度维度，第二个int用于表示宽度维度

• 参数：

  • kernel_size(Union[int,Tuple[int,int]]) : 执行最大池化的窗口大小
  • stride(Union[int,Tuple[int,int]]) : 执行最大池化窗口的步长，默认值是窗口的大小。
  • padding(Union[int,Tuple[int,int]]) : 两边隐式添加零填充
  • dilation(Union[int,Tuple[int,int]]) ：控制窗口中元素步幅的参数
  • return_indices(bool) : 如果为True，将返回输出的最大索引。再后续会对torch.nn.MaxUnpool2d有用。****
  • ceil_mode : 当为True时，将使用ceil而不是floor来计算输出形状。

• 形状：

  • 输入：$(N,C,H_{in},W_{in})$ 或者$(C,H_{in},W_{in})$
  • 输出：$(N,C,H_{out},W_{out})$或者$(C,H_{out},W_{out})$

• 例子

  # pool of square window of size=3, stride=2
  m = nn.MaxPool2d(3, stride=2)
  # pool of non-square window
  m = nn.MaxPool2d((3, 2), stride=(2, 1))
  input = torch.randn(20, 16, 50, 32)
  output = m(input)
  

AvgPool2d

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

• 功能

在由几个输入平面组成的输入信号上应用二维平均池化。

当输入的大小为$(N,C,H,W)$, 输出$(N,C,H_{out},W_{out})$, 卷积核大小$(kH,kW)$

$\mathrm{out}\left(N_i,C_j,h,w\right)=\frac{1}{kH\ast kW}{\sum }_{m=0}^{kH-1}{\sum }_{n=0}^{kW-1}\mathrm{input}\left(N_i,C_j,\text{ stride }[0]\times h+m,\text{ stride }[1]\times w+n\right)$

如果padding非零，则输入两边隐式填充零，以填充点数。

当ceil_mode=True时，如果滑动窗口从左内边距或输入框内开始，则允许滑动窗口越界。从右侧填充区域开始的滑动窗口将被忽略。

参数kernel_size、stride、padding可以是:

1. 单个int——在这种情况下，高度和宽度维度使用相同的值

2. 由两个int组成的元组——在这种情况下，第一个int用于表示高度维度，第二个int用于表示宽度维度

• 参数

  • kernel_size(Union[int,Tuple[int,int]]) : 执行池化的窗口大小
  • stride(Union[int,Tuple[int,int]]) : 执行最大池化窗口的步长，默认值是窗口的大小。
  • padding(Union[int,Tuple[int,int]]) : 两边隐式添加零填充
  • ceil_mode : 当为True时，将使用ceil而不是floor来计算输出形状
  • count_include_pad(bool) : 当为True时，将在平均计算中包括零填充
  • divisor_override(optional[int]) : 如果指定，它将被用作除数，否则将使用池化区域的大小。

• 形状

  • 输入：$\left(N,C,H_{in},W_{in}\right)$ 或者 $\left(C,H_{in},W_{in}\right)$

  • 输出：$\left(N,C,H_{\text{out }},W_{\text{out }}\right)$ 或者 $\left(C,H_{\text{out }},W_{\text{out }}\right)$, 其中

    $$\begin{array}{rl}{H}_{\text{out }}& =\lfloor \frac{H_{\text{in }}+2\times \text{ padding }[0]-\text{ kernelsize }[0]}{\mathrm{stride}[0]}+1\rfloor \\ W_{\text{out }}& =\lfloor \frac{W_{\text{in }}+2\times \text{ padding }[1]-\text{ kernelsize }[1]}{\text{ stride }[1]}+1\rfloor \end{array}$$

• 例子

# pool of square window of size=3, stride=2
m = nn.AvgPool2d(3, stride=2)
# pool of non-square window
m = nn.AvgPool2d((3, 2), stride=(2, 1))
input = torch.randn(20, 16, 50, 32)
output = m(input)

AdaptiveAvgPool2d

CLASS
torch.nn.AdaptiveAvgPool2d(output_size)

• 功能： 在由几个输入平面组成的输入信号上应用二维自适应平均池化。对于任何输入大小，输出的大小均是$H\times W$。输出的特征数等于与输入平面的数量。

• 参数

  • output_size(Union[int,None,Tuple[]Optional[int],Optional[int]]) : H x W形式的图像的目标输出大小可以是一个元组(H, W)或一个单独的H，对于正方形图像H x H H和W可以是一个int，或者None，这意味着大小将与输入相同。

• 形状

  • 输入：$(N,C,H_{in},W_{in})$ 或者$(C,H_{in},W_{in})$
  • 输出：$(N,C,S_0,S_1)$ 或者 $(C,S_0,S_1)$ , 其中$S=output\_size$

• 例子

  # target output size of 5x7
  m = nn.AdaptiveAvgPool2d((5,7))
  input = torch.randn(1, 64, 8, 9)
  output = m(input)
  # target output size of 7x7 (square)
  m = nn.AdaptiveAvgPool2d(7)
  input = torch.randn(1, 64, 10, 9)
  output = m(input)
  # target output size of 10x7
  m = nn.AdaptiveAvgPool2d((None, 7))
  input = torch.randn(1, 64, 10, 9)
  output = m(input)
  

MaxUnpool2d

CLASS
torch.nn.MaxUnpool2d(kernel_size, stride=None, padding=0)

• 功能：计算MaxPool2d的逆运算 （MaxPool2d并不是完全可逆的，因为部分非最大的信息是丢失的）

• 参数

  • kernel_size(int or tuple) : 最大池化的窗口大小
  • stride(int or tuple) : 最大池化窗口的步长，默认为kernel_size。
  • padding(int or tuple) : 添加在input上的填充

• 输入

  • input: 输入的待转换的的张量
  • indices: MaxPool2d中给出的索引
  • output_size(optional): 输出的目标大小

• 形状

  • 输入：$(N,C,H_{in},W_{in})$ 或$(C,H_{in},W_{in})$

  • 输出：$(N,C,H_{out},W_{out})$ 或$(C,H_{out},W_{out})$

    $$\begin{array}{c}{H}_{\text{out }}=\left(H_{\text{in }}-1\right)\times \mathrm{stride}[0]-2\times \mathrm{padding}[0]+\mathrm{kernel}\_\text{size }[0]\\ W_{\text{out }}=\left(W_{\text{in }}-1\right)\times \mathrm{stride}[1]-2\times \text{ padding }[1]+\text{ kernel\_size }[1]\end{array}$$

    或者在output_size中的call operator中给出

• 例子

>>> pool = nn.MaxPool2d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool2d(2, stride=2)
>>> input = torch.tensor([[[[ 1.,  2.,  3.,  4.],
                            [ 5.,  6.,  7.,  8.],
                            [ 9., 10., 11., 12.],
                            [13., 14., 15., 16.]]]])
>>> output, indices = pool(input)
>>> unpool(output, indices)
tensor([[[[  0.,   0.,   0.,   0.],
          [  0.,   6.,   0.,   8.],
          [  0.,   0.,   0.,   0.],
          [  0.,  14.,   0.,  16.]]]])
>>> # Now using output_size to resolve an ambiguous size for the inverse
>>> input = torch.torch.tensor([[[[ 1.,  2.,  3., 4., 5.],
                                  [ 6.,  7.,  8., 9., 10.],
                                  [11., 12., 13., 14., 15.],
                                  [16., 17., 18., 19., 20.]]]])
>>> output, indices = pool(input)
>>> # This call will not work without specifying output_size
>>> unpool(output, indices, output_size=input.size())
tensor([[[[ 0.,  0.,  0.,  0.,  0.],
          [ 0.,  7.,  0.,  9.,  0.],
          [ 0.,  0.,  0.,  0.,  0.],
          [ 0., 17.,  0., 19.,  0.]]]])