[深度学习] 池化层函数及其逆过程函数

池化函数

最大池化函数

• 一维
  class torch.nn.MaxPool1d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
• 二维
  class torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
• 三维
  class torch.nn.MaxPool3d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

对于输入信号的输入通道，提供一维、二维、三维最大池化（max pooling）操作

参数：

• kernel_size(int or tuple) - max pooling的窗口大小
• stride(int or tuple, optional) - max pooling的窗口移动的步长。默认值是kernel_size
• padding(int or tuple, optional) - 输入的每一条边补充0的层数
• dilation(int or tuple, optional) – 一个控制窗口中元素步幅的参数
• return_indices - 如果等于True，会返回输出最大值的序号，对于上采样操作会有帮助
• ceil_mode - 如果等于True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的操作。

shape:

• 一维最大池化层
  输入: (N,C_in,L_in)
  输出: (N,C_out,L_out)
  $$L_{out}=floor((L_{in}+2padding-dilation(kerne{l}_{s}ize-1)-1)/stride+1$$

• 二维最大池化层
  输入: (N,C,H_{in},W_in)
  输出: (N,C,H_out,W_out)
  $$H_{out}=floor((H_{in}+2padding[0]-dilation[0](kerne{l}_{s}ize[0]-1)-1)/stride[0]+1$$ $$W_{out}=floor((W_{in}+2padding[1]-dilation[1](kerne{l}_{s}ize[1]-1)-1)/stride[1]+1$$

• 三维最大池化层
  输入: (N,C,H_in,W_in)
  输出: (N,C,H_out,W_out)
  $$D_{out}=floor((D_{in}+2padding[0]-dilation[0](kerne{l}_{s}ize[0]-1)-1)/stride[0]+1)$$ $$H_{out}=floor((H_{in}+2padding[1]-dilation[1](kerne{l}_{s}ize[0]-1)-1)/stride[1]+1)$$ $$W_{out}=floor((W_{in}+2padding[2]-dilation[2](kerne{l}_{s}ize[2]-1)-1)/stride[2]+1)$$

Example：

一维最大池化层

# pool of size=3, stride=2
m = nn.MaxPool1d(3, stride=2)
input = autograd.Variable(torch.randn(20, 16, 50))
output = m(input)

二维最大池化层

# 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 = autograd.Variable(torch.randn(20, 16, 50, 32))
output = m(input)

三维最大池化层

# pool of square window of size=3, stride=2
m = nn.MaxPool3d(3, stride=2)
# pool of non-square window
m = nn.MaxPool3d((3, 2, 2), stride=(2, 1, 2))
input = autograd.Variable(torch.randn(20, 16, 50,44, 31))  
output = m(input)

平均池化函数

• 一维
  class torch.nn.AvgPool1d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True) 和
• 二维
  class torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True)
• 三维
  class torch.nn.AvgPool3d(kernel_size, stride=None)

对信号的输入通道，提供一维、二维、三维的平均池化（average pooling ）

参数：
一维、二维平均池化

• kernel_size(int or tuple) - 池化窗口大小
• stride(int or tuple, optional) - max pooling的窗口移动的步长。默认值是kernel_size
• padding(int or tuple, optional) - 输入的每一条边补充0的层数
• dilation(int or tuple, optional) – 一个控制窗口中元素步幅的参数
• count_include_pad - 如果等于True，计算平均池化时，将包括padding填充的0
• ceil_mode - 如果等于True，计算输出信号大小的时候，会使用向上取整，代替默认的向下取整的操作

三维平均池化
kernel_size(int or tuple) - 池化窗口大小
stride(int or tuple, optional) - avg pooling的窗口移动的步长。默认值是kernel_size

shape：

• 一维平均池化
  input:(N,C,L_in)
  output:(N,C,L_out)
  $$L_{out}=floor((L_{in}+2\ast padding-kernel\_size)/stride+1)$$

• 二维平均池化
  input: (N,C,H_in,W_in)
  output: (N,C,H_out,W_out)
  $$H_{out}=floor((H_{in}+2padding[0]-kerne{l}_{s}ize[0])/stride[0]+1)$$ $$W_{out}=floor((W_{in}+2padding[1]-kerne{l}_{s}ize[1])/stride[1]+1)$$

• 三维平均池化
  输入大小:(N,C,D_in,H_in,W_in)
  输出大小:(N,C,D_out,H_out,W_out)
  $$D_{out}=floor((D_{in}+2padding[0]-kerne{l}_{s}ize[0])/stride[0]+1)$$ $$H_{out}=floor((H_{in}+2padding[1]-kerne{l}_{s}ize[1])/stride[1]+1)$$ $$W_{out}=floor((W_{in}+2\ast padding[2]-kerne{l}_{s}ize[2])/stride[2]+1)$$

Example:
一维平均池化

>>> # pool with window of size=3, stride=2
>>> m = nn.AvgPool1d(3, stride=2)
>>> m(Variable(torch.Tensor([[[1,2,3,4,5,6,7]]])))
Variable containing:
    (0 ,.,.) =
    2  4  6
    [torch.FloatTensor of size 1x1x3]

二维平均池化

>>> # 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 = autograd.Variable(torch.randn(20, 16, 50, 32))
>>> output = m(input)

三维平均池化

>>> # pool of square window of size=3, stride=2
>>> m = nn.AvgPool3d(3, stride=2)
>>> # pool of non-square window
>>> m = nn.AvgPool3d((3, 2, 2), stride=(2, 1, 2))
>>> input = autograd.Variable(torch.randn(20, 16, 50,44, 31))
>>> output = m(input)

池化逆函数

最大池化的近似逆函数

• 一维
  class torch.nn.MaxUnpool1d(kernel_size, stride=None, padding=0)
• 二维
  class torch.nn.MaxUnpool2d(kernel_size, stride=None, padding=0)
• 三维
  class torch.nn.MaxUnpool3d(kernel_size, stride=None, padding=0)

Maxpool1d、Maxpool2d、Maxpool3d的逆过程，不过并不是完全的逆过程，因为在maxpool1d、maxpool2d、maxpool3d的过程中，一些最大值的已经丢失。 MaxUnpool1d、MaxUnpool2d、 MaxUnpool3d输入MaxPool1d、MaxPool2d、MaxPool3d的输出，包括最大值的索引，并计算所有maxpool1d、maxpool2d、maxpool3d过程中非最大值被设置为零的部分的反向。

注意：
MaxPool1d、MaxPool2d、MaxPool3d可以将多个输入大小映射到相同的输出大小。因此，反演过程可能会变得模棱两可。 为了适应这一点，可以在调用中将输出大小（output_size）作为额外的参数传入。 具体用法，请参阅下面的输入和示例

参数：

• kernel_size(int or tuple) - max pooling的窗口大小
• stride(int or tuple, optional) - max pooling的窗口移动的步长。默认值是kernel_size
• padding(int or tuple, optional) - 输入的每一条边补充0的层数

输入：

• input:需要转换的tensor
• indices：Maxpool1d的索引号
• output_size:一个指定输出大小的torch.Size

shape:

• 一维逆池化
  input: (N,C,H_in)
  output:(N,C,H_out)
  $$H_{out}=(H_{in}-1)stride[0]-2padding[0]+kernel\_size[0]$$ 也可以使用output_size指定输出的大小
• 二维逆池化
  input: (N,C,H_in,W_in)
  output:(N,C,H_out,W_out)
  $$H_{out}=(H_{in}-1)stride[0]-2padding[0]+kernel\_size[0]$$ $$W_{out}=(W_{in}-1)stride[1]-2padding[1]+kernel\_size[1]$$
  也可以使用output_size指定输出的大小
• 三维逆池化
  input: (N,C,D_in,H_in,W_in)
  output:(N,C,D_out,H_out,W_out)
  $$D_{out}=(D_{in}-1)stride[0]-2padding[0]+kernel\_size[0]$$ $$H_{out}=(H_{in}-1)stride[1]-2padding[0]+kernel\_size[1]$$ $$W_{out}=(W_{in}-1)stride[2]-2padding[2]+kernel\_size[2]$$ 也可以使用output_size指定输出的大小

Example：

一维逆池化

>>> pool = nn.MaxPool1d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool1d(2, stride=2)
>>> input = Variable(torch.Tensor([[[1, 2, 3, 4, 5, 6, 7, 8]]]))
>>> output, indices = pool(input)
>>> unpool(output, indices)
    Variable containing:
    (0 ,.,.) =
       0   2   0   4   0   6   0   8
    [torch.FloatTensor of size 1x1x8]

>>> # Example showcasing the use of output_size
>>> input = Variable(torch.Tensor([[[1, 2, 3, 4, 5, 6, 7, 8, 9]]]))
>>> output, indices = pool(input)
>>> unpool(output, indices, output_size=input.size())
    Variable containing:
    (0 ,.,.) =
       0   2   0   4   0   6   0   8   0
    [torch.FloatTensor of size 1x1x9]
>>> unpool(output, indices)
    Variable containing:
    (0 ,.,.) =
       0   2   0   4   0   6   0   8
    [torch.FloatTensor of size 1x1x8]

二维逆池化

>>> pool = nn.MaxPool2d(2, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool2d(2, stride=2)
>>> input = Variable(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)
    Variable containing:
    (0 ,0 ,.,.) =
       0   0   0   0
       0   6   0   8
       0   0   0   0
       0  14   0  16
    [torch.FloatTensor of size 1x1x4x4]

>>> # specify a different output size than input size
>>> unpool(output, indices, output_size=torch.Size([1, 1, 5, 5]))
    Variable containing:
    (0 ,0 ,.,.) =
       0   0   0   0   0
       6   0   8   0   0
       0   0   0  14   0
      16   0   0   0   0
       0   0   0   0   0
    [torch.FloatTensor of size 1x1x5x5]

三维逆池化

>>> # pool of square window of size=3, stride=2
>>> pool = nn.MaxPool3d(3, stride=2, return_indices=True)
>>> unpool = nn.MaxUnpool3d(3, stride=2)
>>> output, indices = pool(Variable(torch.randn(20, 16, 51, 33, 15)))
>>> unpooled_output = unpool(output, indices)
>>> unpooled_output.size()
torch.Size([20, 16, 51, 33, 15])