【深度学习入门篇 ⑦】PyTorch池化层

【🍊易编橙：一个帮助编程小伙伴少走弯路的终身成长社群🍊】

大家好，我是小森( ﹡ˆoˆ﹡ ) ！ 易编橙·终身成长社群创始团队嘉宾，橙似锦计划领衔成员、阿里云专家博主、腾讯云内容共创官、CSDN人工智能领域优质创作者 。

---

池化层 (Pooling) 降低维度，缩减模型大小，提高计算速度即: 主要对卷积层学习到的特征图进行下采样（SubSampling）处理 。

• 通过下采样，我们可以提取出特征图中最重要的特征，同时忽略掉一些不重要的细节。
• 上采样是指增加数据（图像）的尺寸；通常用于图像的分割、超分辨率重建或生成模型中，以便将特征图恢复到原始图像的尺寸或更大的尺寸。 

池化层

池化包含最大池化和平均池化，有一维池化，二维池化，三维池化，在这里以二维池化为例

最大池化

最大池化就是求一个区域中的最大值，来代替该区域。

torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

假设输入的尺寸是(𝑁,𝐶,𝐻,𝑊)，输出尺寸是(𝑁,𝐶,𝐻𝑜𝑢𝑡,𝑊𝑜𝑢𝑡)，kernel_size是(𝑘𝐻,𝑘𝑊)，可以写成下面形式 ：

其中，输入参数 kernel_size，stride，padding，dilation可以是

• 一个 int ：代表长宽使用同样的参数
• 两个int组成的元组：第一个int用在H维度，第二个int用在W维度

import torch
import torch.nn as nn
#长宽一致的池化,核尺寸为3x3，池化步长为2
ml = nnMaxPool2d(3, stride=2)
#长宽不一致的池化
m2 = nn.MaxPool2d((3,2), stride=(2,1))
input = torch.randn(4,3,24,24)
output1 = m1( input)
output2 = m2( input)
print( "input.shape = " ,input.shape)
print( "output1.shape = " , output1.shape)
print( "output2.shape = " , output2.shape)

 输出：

input.shape = torch.size([4，3，24，24])
output1.shape = torch. size([4，3，11，11])
output2.shape = torch.size([4，3，11，23])

平均池化

平均池化就是用一个区域中的平均数来代替本区域

torch.nn.AvgPool2d(kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True, divisor_override=None)

---

import torch
import torch.nn as nn
#长宽一致的池化,核尺寸为3x3，池化步长为2
ml = nn. AvgPool2d( 3, stride=2)
#长宽不一致的池化
m2 = nn. AvgPool2d(( 3,2), stride=(2,1) )
input = torch.randn(4,3,24,24)
output1 = m1( input)
output2 = m2( input)
print("input.shape = ",input. shape)
print("output1.shape = " , output1.shape)
print( "output2.shape = ", output2.shape)

• randn是生成形状为[batch_size, channels, height, width] 

输出：

input.shape = torch.size([4，3，24，24])
output1.shape = torch.size([4，3，11，11])
output2.shape = torch.size([4，3，11，23])

BN层

BN，即Batch Normalization，是对每一个batch的数据进行归一化操作，可以使得网络训练更稳定，加速网络的收敛。

import torch
import torch.nn as nn
#批量归一化层（具有可学习参数)
m_learnable = nn. BatchNorm2d(100)
#批量归一化层(不具有可学习参数)
m_non_learnable = nn.BatchNorm2d(100,affine=False)
#随机生成输入数据
input = torch.randn(20,100,35,45)
#应用具有可学习参数的批量归一化层
output_learnable = m_learnable(input)
#应用不具有可学习参数的批量归一化层
output_non_learnable = m_non_learnable(input)
print( "input.shape = ", input.shape)
print( "output_learnable.shape = ", output_learnable.shape)
print( "output_non_learnable.shape = ", output_non_learnable.shape)

 输出：

input.shape = torch.size([20，100，35，45])
output_learnable.shape = torch.size( [20,100,35,45])
output_non_learnable.shape = torch.size([20,100,35,45])

常见的层就是上面提到的这些，如果这些层结构被反复调用，我们可以将其封装成一个个不同的模块。

案例：复现LeNet

LeNet结构，使用PyTorch进行复现，卷积核大小5x5，最大池化层，核大小2x2

import torch
import torch.nn as nn
from torchsummary import summary
class LeNet( nn . Module):
    def _init_( self,num_classes=10):
        super(Leet, self)._init__()
        self.conv1 = nn.conv2d( in_channels=3,out_channels=6,kernel_size=5)
        self.pool1 = nn. MaxPool2d(kernel_size=2)
        self.conv2 = nn.Conv2d(in_channels=6,out_channels=16,kernel_size=5)
        self.pool2 = nn. MaxPool2d(kernel_size=2)
        self.conv3 = nn.conv2d(in_channels=16,out_channels=120, kernel_size=5)
        self.fc1 = nn.Linear(in_features=120,out_features=84)
        self.fc2 = nn.Linear(in_features=84,out_features=10)
    
    def forward(self, x):
        #通过卷积层、ReLU和池化层
        x = self.conv1(x)
        x = self.pool1(x)
        x = self.conv2(x)
        x = self.pool2(x)
        x = self.conv3(x)
        x = x.view( -1，120)
        x = self.fc1(x)
        x = self.fc2(x)
        return x
#创建网络实例
num_classes = 10
net = LeNet( num_classes)

#创建一个输入
batch_size = 4
input_tensor = torch.randn(batch_size,3,32,32)
# 假设输入是32x32的RGB图像
#将输入Tensor传递给网络
output = net(input_tensor)
# #显示输出Tensor的形状
print(output.shape)
summary(net,(3,32,32))

Sequential: 顺序容器

Sequential属于顺序容器。模块将按照在构造函数中传递的顺序从上到下进行运算。

使用OrderedDict，可以进一步对传进来的层进行重命名。

#使用sequential来创建小模块，当有输入进来，会从上到下依次经过所有模块
model = nn. Sequential(
nn.conv2d(1,20,5),nn.ReLu() ,
nn.conv2d(20,64,5),nn.ReLU()
)
#使用orderedDict，可以对传进来的模块进行命名，实现效果同上
from collections import orderedDict
model = nn. sequential ( orderedDict([
        ( 'conv1 ', nn.Conv2d( 1,20,5)),
        ( 'relu1 ', nn.ReLU( ) ),
        ( 'conv2 ', nn.conv2d(20,64,5)),
        ( 'relu2 ', nn.ReLU())
]))

除此之外，还可以用 ModuleList和 ModuleDict 来存放子模块，但是用的不多，掌握了上面的内容就足够了。