title: How does adaptive pooling in pytorch work?
body: <p>Adaptive pooling is a great function, but how does it work?  It seems to be inserting pads or shrinking/expanding kernel sizes in what seems like a pattered but fairly arbitrary way.  The pytorch documentation I can find is not more descriptive than "put desired output size here."  Does anyone know how this works or can point to where it's explained?</p>
  
  <p>Some test code on a 1x1x6 tensor, (1,2,3,4,5,6), with an adaptive output of size 8:</p>
  
  <pre><code>import torch
  import torch.nn as nn
  
  class TestNet(nn.Module):
      def __init__(self):
          super(TestNet, self).__init__()
          self.avgpool = nn.AdaptiveAvgPool1d(8)
  
      def forward(self,x):
          print(x)
          x = self.avgpool(x)
          print(x)
          return x
  
  def test():
      x = torch.Tensor([[[1,2,3,4,5,6]]])
      net = TestNet()
      y = net(x)
      return y
  
  test()
  </code></pre>
  
  <p>Output:</p>
  
  <pre><code>tensor([[[ 1.,  2.,  3.,  4.,  5.,  6.]]])
  tensor([[[ 1.0000,  1.5000,  2.5000,  3.0000,  4.0000,  4.5000,  5.5000,
         6.0000]]])
  </code></pre>
  
  <p>If it mirror pads by on the left and right (operating on (1,1,2,3,4,5,6,6)), and has a kernel of 2, then the outputs for all positions except for 4 and 5 make sense, except of course the output isn't the right size.  Is it also padding the 3 and 4 internally?  If so, it's operating on (1,1,2,3,3,4,4,5,6,6), which, if using a size 2 kernel, produces the wrong output size and would also miss a 3.5 output.  Is it changing the size of the kernel?</p>
  
  <p>Am I missing something obvious about the way this works?</p>