PyTorch的自适应池化Adaptive Pooling实例

官方给出的例子：
> # 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])

> 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])

 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 < 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 < kH; ih++)
     {
      for(iw = 0; iw < kW; iw++)
      {
       scalar_t val = *(ip + ih*istrideH + iw*istrideW);
       sum += val;
      }
     }

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