nn.AdaptiveAvgPool2d和nn.AvgPool2d的区别

nn.AdaptiveAvgPool2d

功能:该函数与二维平均池化运算类似,区别主要体现在自适应上,对于任何输入大小,输出大小均为指定的H×W大小。

nn.AdaptiveAvgPool2d(output_size)

output_size:指定的输出大小,可以是元组(H,W),或者是单个的数,如果是单个的数,则表示输出的高和宽尺寸一样,output_size大小可以大于输入的图片尺寸大小。
例子:


import torch # target output size of 5x7
import torch.nn as nn
m = nn.AdaptiveAvgPool2d((5,7))
input = torch.randn(1, 64, 8, 9)
output = m(input)
print(output.shape)
# target output size of 7x7 (square)
m = nn.AdaptiveAvgPool2d(7)
input = torch.randn(1, 64, 10, 9)
output = m(input)
print(output.shape)
# target output size of 10x7
m = nn.AdaptiveAvgPool2d((None, 7))
input = torch.randn(1, 64, 10, 9)
output = m(input)
print(output.shape)
m = nn.AdaptiveAvgPool2d(1)
input = torch.randn(1, 64, 10, 9)
output = m(input)
print(output.shape)

运行结果:

torch.Size([1, 64, 5, 7])
torch.Size([1, 64, 7, 7])
torch.Size([1, 64, 10, 7])
torch.Size([1, 64, 1, 1])

应用

用在SE注意力机制上,代码如下:

class SELayer(nn.Module):
    def __init__(self, channel, reduction=16):
        super(SELayer, self).__init__()
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(channel, channel // reduction, bias=False),
            nn.ReLU(inplace=True),
            nn.Linear(channel // reduction, channel, bias=False),
            nn.Sigmoid()
        )

    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.avg_pool(x)
        y=y.view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        return x * y.expand_as(x)

输入大小是b×c×h×w经过avg_pool后变成了b×c×1×1。

还有用到的地方是在网络的Block后面,例如ResNet:

    self.avgpool = nn.AdaptiveAvgPool2d((1, 1))

输出的结果为:
nn.AdaptiveAvgPool2d和nn.AvgPool2d的区别_第1张图片

nn.AvgPool2d

功能:在由多个平面组成的输入信号上应用2D平均池化操作。
重要参数:

kernel_size:池化核的尺寸大小
stride:窗口的移动步幅,默认与kernel_size大小一致
padding:在两侧的零填充宽度大小

注:这三个参数既可以是整数也可以是元组
整数,这种情况下,高和宽尺寸相同
元组,包含两个整数,第一个用于高度维度,第二个用于宽度维度

应用

和AdaptiveAvgPool2d用法相似,比如用在SE模块里使用,代码如下:

class SqueezeAndExcite(nn.Module):
    def __init__(self, in_channels, out_channels,se_kernel_size, divide=4):
        super(SqueezeAndExcite, self).__init__()
        mid_channels = in_channels // divide
        self.pool = nn.AvgPool2d(kernel_size=se_kernel_size,stride=1)
        self.SEblock = nn.Sequential(
            nn.Linear(in_features=in_channels, out_features=mid_channels),
            nn.ReLU6(inplace=True),
            nn.Linear(in_features=mid_channels, out_features=out_channels),
            HardSwish(inplace=True),
        )

    def forward(self, x):
        b, c, h, w = x.size()
        out = self.pool(x)
        out = out.view(b, -1)
        out = self.SEblock(out)
        out = out.view(b, c, 1, 1)
        return out * x

想要把b×c×h×w经过avg_pool后变成了b×c×1×1,就要先知道输入的h和w大小,将其赋值给se_kernel_size,如果写成固定的,将来改变图片的尺寸就会出现问题。
同理ResNet也有这样的问题,如果图片是224×224的,经过block后,h和w都是7,这时候,设置如下:

  self.avgpool = nn.AvgPool2d(7, stride=1)

但是如果改变图片的尺寸就会出现问题,比如将尺寸扩大了一倍,这时候经过block之后的尺寸是14×14,这个时候就要更改网络才行,但是如果使用AdaptiveAvgPool2d则没有这个烦恼。

你可能感兴趣的:(深度学习基础,人工智能,深度学习,pytorch)