PyTorch的自适应池化Adaptive Pooling

最新推荐文章于 2024-04-26 00:11:24 发布

Arthur-Ji

最新推荐文章于 2024-04-26 00:11:24 发布

阅读量1.6k

点赞数

分类专栏： pytorch

原文链接：https://blog.csdn.net/u013382233/article/details/85948695

版权

pytorch 专栏收录该内容

54 篇文章 1 订阅

订阅专栏

简介

自适应池化Adaptive Pooling是PyTorch含有的一种池化层，在PyTorch的中有六种形式：

自适应最大池化Adaptive Max Pooling：
torch.nn.AdaptiveMaxPool1d(output_size)
torch.nn.AdaptiveMaxPool2d(output_size)
torch.nn.AdaptiveMaxPool3d(output_size)

自适应平均池化Adaptive Average Pooling：
torch.nn.AdaptiveAvgPool1d(output_size)
torch.nn.AdaptiveAvgPool2d(output_size)
torch.nn.AdaptiveAvgPool3d(output_size)

具体可见官方文档。

官方给出的例子：
>>> # target output size of 5x7
>>> m = nn.AdaptiveMaxPool2d((5,7))
>>> input = torch.randn(1, 64, 8, 9)
>>> output = m(input)
>>> output.size()
torch.Size([1, 64, 5, 7])

>>> # target output size of 7x7 (square)
>>> m = nn.AdaptiveMaxPool2d(7)
>>> input = torch.randn(1, 64, 10, 9)
>>> output = m(input)
>>> output.size()
torch.Size([1, 64, 7, 7])

>>> # target output size of 10x7
>>> m = nn.AdaptiveMaxPool2d((None, 7))
>>> input = torch.randn(1, 64, 10, 9)
>>> output = m(input)
>>> output.size()
torch.Size([1, 64, 10, 7])

Adaptive Pooling特殊性在于，输出张量的大小都是给定的 $output_sizeoutput_size output\_size$ $s t r i d e$ 。
通过以下的例子，我们看一下这三个参数的关系：

>>> inputsize = 9
>>> outputsize = 4

>>> input = torch.randn(1, 1, inputsize)
>>> input
tensor([[[ 1.5695, -0.4357, 1.5179, 0.9639, -0.4226, 0.5312, -0.5689, 0.4945, 0.1421]]])

>>> m1 = nn.AdaptiveMaxPool1d(outputsize)
>>> m2 = nn.MaxPool1d(kernel_size=math.ceil(inputsize / outputsize), stride=math.floor(inputsize / outputsize), padding=0)
>>> output1 = m1(input)
>>> output2 = m2(input)

>>> output1
tensor([[[1.5695, 1.5179, 0.5312, 0.4945]]]) torch.Size([1, 1, 4])
>>> output2
tensor([[[1.5695, 1.5179, 0.5312, 0.4945]]]) torch.Size([1, 1, 4])

通过实验发现：
$stride=floor(input_size/output_size)stride=floor(input_size/output_size) stride=floor(input\_size/output\_size)$ $f l o o r$ 为向下取整。

下面是Adaptive Average Pooling的c++源码部分。

 template <typename scalar_t>
  static void adaptive_avg_pool2d_out_frame(
            scalar_t *input_p,
            scalar_t *output_p,
            int64_t sizeD,
            int64_t isizeH,
            int64_t isizeW,
            int64_t osizeH,
            int64_t osizeW,
            int64_t istrideD,
            int64_t istrideH,
            int64_t istrideW)
  {
    int64_t d;
  #pragma omp parallel for private(d)
    for (d = 0; d < sizeD; d++)
    {
      /* loop over output */
      int64_t oh, ow;
      for(oh = 0; oh < osizeH; oh++)
      {
        int istartH = start_index(oh, osizeH, isizeH);
        int iendH   = end_index(oh, osizeH, isizeH);
        int kH = iendH - istartH;
    for(ow = 0; ow &lt; osizeW; ow++)
    {
      int istartW = start_index(ow, osizeW, isizeW);
      int iendW   = end_index(ow, osizeW, isizeW);
      int kW = iendW - istartW;

      /* local pointers */
      scalar_t *ip = input_p   + d*istrideD + istartH*istrideH + istartW*istrideW;
      scalar_t *op = output_p  + d*osizeH*osizeW + oh*osizeW + ow;

      /* compute local average: */
      scalar_t sum = 0;
      int ih, iw;
      for(ih = 0; ih &lt; kH; ih++)
      {
        for(iw = 0; iw &lt; kW; iw++)
        {
          scalar_t val = *(ip + ih*istrideH + iw*istrideW);
          sum += val;
        }
      }

      /* set output to local average */
      *op = sum / kW / kH;
    }
  }
}

}