PyTorch - torch.nn.AdaptiveAvgPool2d

PyTorch - torch.nn.AdaptiveAvgPool2d

flyfish

自适应平均池化

torch.nn.AdaptiveAvgPool2d 对应的是torch.nn.functional.adaptive_avg_pool2d

输出数据相当于 minibatch x channels x height x width

import torch
import torch.nn as nn
input = torch.arange(0, 16).view(1,1,4,4).float()
# tensor([[[[ 0.,  1.,  2.,  3.],
#           [ 4.,  5.,  6.,  7.],
#           [ 8.,  9., 10., 11.],
#           [12., 13., 14., 15.]]]])

计算平均数

print('mean:',torch.mean(input)) #mean: tensor(7.5000)
m = nn.AdaptiveAvgPool2d((1))
output = m(input)

下面分别以参数各种形式的例子，并说明中间过程是如何计算的

方式1
#avg average

AdaptiveAvgPool2d((1))

该情况相当于torch.mean(input)，所有的数累加起来求一个均值
#---------------------------------------------------------------------------------------------
方式2

m = nn.AdaptiveAvgPool2d((4,1))

#输出结果是

# tensor([[[[ 1.5000],
#           [ 5.5000],
#           [ 9.5000],
#           [13.5000]]]])

计算过程每行的数 各自加起来，然后按行各自求均值

(0+1+2+3)/4=1.5

(4+5+6+7)/4=5.5

(8+9+10+11)/4=9.5

(12+13+14+15)/4=13.5

#---------------------------------------------------------------------------------------------
方式3

nn.AdaptiveAvgPool2d((3,1))

输出结果是

# tensor([[[[ 3.5000],
#           [ 7.5000],
#           [11.5000]]]])

先按照上面的方式2计算一遍，之后然后再两两计算均值

(1.5+5.5)/2=3.5

(5.5+9.5)/2=7.5

(9.5+13.5)/2=11.5

#---------------------------------------------------------------------------------------------
方式4
nn.AdaptiveAvgPool2d((4,2))
输出结果是

# tensor([[[[ 0.5000,  2.5000],
#           [ 4.5000,  6.5000],
#           [ 8.5000, 10.5000],
#           [12.5000, 14.5000]]]])

计算过程是

(0+1)/2=0.5 (2+3)/2=2.5

(4+5)/2=4.5 (6+7)/2=6.5

(8+9)/2=8.5 (10+11)/2=10.5

(12+13)/2=12.5 (14+15)/2=14.5

#---------------------------------------------------------------------------------------------
方式5

nn.AdaptiveAvgPool2d((3,2))

输出结果是

# tensor([[[[ 2.5000,  4.5000],
#           [ 6.5000,  8.5000],
#           [10.5000, 12.5000]]]])

计算过程按照上面的方式4算完之后，再按照下面的计算方式

(0.5+4.5)/2=2.5 (2.5+6.5)/2=4.5

(4.5+8.5)/2=6.5 (6.5+10.5)/2=8.5

(8.5+12.5)/2=10.5 (10.5+14.5)/2=12.5

#---------------------------------------------------------------------------------------------
方式6

nn.AdaptiveAvgPool2d((7,1))

输出行数大于输入行数 输出结果是

# tensor([[[[ 1.5000],
#           [ 3.5000],
#           [ 5.5000],
#           [ 7.5000],
#           [ 9.5000],
#           [11.5000],
#           [13.5000]]]])