「深度学习一遍过」必修13：使用pytorch对Inception结构模型进行设计_python 中self.conv2 = nn.conv2d(16,32,3,1,1)-优快云博客

本文链接：https://blog.youkuaiyun.com/IT_charge/article/details/119415505

本文探讨了如何在基准模型基础上，逐步替换卷积层为Inception结构，以提升模型性能。Inception模块通过多尺度卷积降低参数量并保持性能。通过实例代码展示了conv2、conv3、conv4和conv5的改造，最后对比了各模型在实际任务中的表现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本专栏用于记录关于深度学习的笔记，不光方便自己复习与查阅，同时也希望能给您解决一些关于深度学习的相关问题，并提供一些微不足道的人工神经网络模型设计思路。
专栏地址：「深度学习一遍过」必修篇

目录

1 基准模型

2 替换第2个卷积为Inception结构（conv2）

3 替换第3个卷积为Inception结构（conv3）

4 替换第4个卷积为Inception结构（conv4）

5 替换第5个卷积为Inception结构（conv5）

6 所有模型比较

1 基准模型

$5$ 层卷积 $+$ 激活函数， $1$ 个全局池化层， $1$ 个全连接分类层。

网络模块	conv1	conv2	conv3	conv4	conv5
通道数	16	32	64	128	256

代码实现

class Inception_benchmark(nn.Module):
    def __init__(self):
        super(Inception_benchmark,self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, 1)
        self.bn1 = nn.BatchNorm2d(16)
        self.conv2 = nn.Conv2d(16, 32, 3, 1)
        self.bn2 = nn.BatchNorm2d(32)
        self.conv3 = nn.Conv2d(32, 64, 3, 1)
        self.bn3 = nn.BatchNorm2d(64)
        self.conv4 = nn.Conv2d(64, 128, 3, 1)
        self.bn4 = nn.BatchNorm2d(128)
        self.conv5 = nn.Conv2d(128, 256, 3, 1) 
        self.bn5 = nn.BatchNorm2d(256)
        self.s = nn.AdaptiveAvgPool2d(2)
        self.fc1 = nn.Linear(1024, 2)

    def forward(self , x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x = F.relu(self.bn3(self.conv3(x)))
        x = F.relu(self.bn4(self.conv4(x)))
        x = F.relu(self.bn5(self.conv5(x)))
        x = self.s(x)
        x = x.view(-1, 1024)
        x = self.fc1(x)
        return x

模型结构

2 替换第2个卷积为Inception结构（conv2）

代码实现

class Inception_conv2(nn.Module):
    def __init__(self):
        super(Inception_conv2, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, 1)
        self.bn1 = nn.BatchNorm2d(16)
        # 第1个分支
        # 使用常规的卷积操作+池化操作，但是不改变通道数，包括conv2和pool2。
        self.conv2 = nn.Conv2d(16, 16, 1)
        self.bn2 = nn.BatchNorm2d(16)
        # 第2个分支(包含3个卷积层)
        self.conv2_1 = nn.Conv2d(16, 8, 1)   # 第一个卷积层为conv2_1，使用的是1×1卷积,输入为16个通道，输出为8个通道
        self.bn2_1 = nn.BatchNorm2d(8)
        self.conv2_2 = nn.Conv2d(8, 8, 3, 2, 1)  # 第二个卷积层为conv2_2，输入为8个通道，输出为8个通道，使用3×3卷积，特征图空间大小减少
        self.bn2_2 = nn.BatchNorm2d(8)
        self.conv2_3 = nn.Conv2d(8, 16, 1)     # 第三个卷积层为conv2_3，输入大小为8个通道，输出大小为16个通道，使用1×1卷积
        self.bn2_3 = nn.BatchNorm2d(16)
        self.in_pool = nn.AvgPool2d(2)
        self.conv3 = nn.Conv2d(32, 64, 3, 1)
        self.bn3 = nn.BatchNorm2d(64)
        self.conv4 = nn.Conv2d(64, 128, 3, 1)
        self.bn4 = nn.BatchNorm2d(128)
        self.conv5 = nn.Conv2d(128, 256, 3, 1)
        self.bn5 = nn.BatchNorm2d(256)
        self.pool1 = nn.AdaptiveMaxPool2d(2)
        self.line1 = nn.Linear(256 * 2 * 2, 128)
        self.line2 = nn.Linear(128, 2)

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x1 = F.relu(self.bn2(self.conv2(x)))
        x1 = self.in_pool(x1)
        x2 = F.relu(self.bn2_1(self.conv2_1(x)))
        x2 = F.relu(self.bn2_2(self.conv2_2(x2)))
        x2 = F.relu(self.bn2_3(self.conv2_3(x2)))
        x = torch.cat((x1, x2), dim=1)   # 通道合并concat操作
        x = self.in_pool(x)
        x = F.relu(self.bn3(self.conv3(x)))
        x = F.relu(self.bn4(self.conv4(x)))
        x = F.relu(self.bn5(self.conv5(x)))
        x = self.pool1(x)
        x = x.view(-1, 256 * 2 * 2)
        x = F.relu(self.line1(x))
        x = self.line2(x)
        return x

模型结构

3 替换第3个卷积为Inception结构（conv3）

代码实现

class Inception_conv3(nn.Module):
    def __init__(self):
        super(Inception_conv3, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, 1)
        self.bn1 = nn.BatchNorm2d(16)
        self.conv2 = nn.Conv2d(16, 32, 3, 1) 
        self.bn2 = nn.BatchNorm2d(32)
        # 第1个分支
        # 使用常规的卷积操作+池化操作，但是不改变通道数，包括conv3和pool3。
        self.conv3 = nn.Conv2d(32, 32, 1)
        self.bn3 = nn.BatchNorm2d(32)
        # 第2个分支(包含3个卷积层)
        self.conv3_1 = nn.Conv2d(32, 16, 1)  # 第一个卷积层为conv3_1，使用的是1×1卷积,输入为32个通道，输出为16个通道
        self.bn3_1 = nn.BatchNorm2d(16)
        self.conv3_2 = nn.Conv2d(16, 16, 3, 2, 1)  # 第二个卷积层为conv3_2，输入为16个通道，输出为16个通道，使用3×3卷积，特征图空间大小减少
        self.bn3_2 = nn.BatchNorm2d(16)
        self.conv3_3 = nn.Conv2d(16, 32, 1)  # 第三个卷积层为conv3_3，输入大小为16个通道，输出大小为32个通道，使用1×1卷积
        self.bn3_3 = nn.BatchNorm2d(32)
        self.in_pool = nn.AvgPool2d(2)
        self.conv4 = nn.Conv2d(64, 128, 3, 1)
        self.bn4 = nn.BatchNorm2d(128)
        self.conv5 = nn.Conv2d(128, 256, 3, 1)
        self.bn5 = nn.BatchNorm2d(256)
        self.pool1 = nn.AdaptiveMaxPool2d(2)
        self.line1 = nn.Linear(256 * 2 * 2, 128)
        self.line2 = nn.Linear(128, 2)

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x1 = F.relu(self.bn3(self.conv3(x)))
        x1 = self.in_pool(x1)
        x2 = F.relu(self.bn3_1(self.conv3_1(x)))
        x2 = F.relu(self.bn3_2(self.conv3_2(x2)))
        x2 = F.relu(self.bn3_3(self.conv3_3(x2)))
        x = torch.cat((x1, x2), dim=1)  # 通道合并concat操作
        x = self.in_pool(x)
        x = F.relu(self.bn4(self.conv4(x)))
        x = F.relu(self.bn5(self.conv5(x)))
        x = self.pool1(x)
        x = x.view(-1, 256 * 2 * 2)
        x = F.relu(self.line1(x))
        x = self.line2(x)
        return x

模型结构

4 替换第4个卷积为Inception结构（conv4）

代码实现

class Inception_conv4(nn.Module):
    def __init__(self):
        super(Inception_conv4, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, 1)
        self.bn1 = nn.BatchNorm2d(16)
        self.conv2 = nn.Conv2d(16, 32, 3, 1)
        self.bn2 = nn.BatchNorm2d(32)
        self.conv3 = nn.Conv2d(32, 64, 3, 1)  
        self.bn3 = nn.BatchNorm2d(64)
        # 第1个分支
        # 使用常规的卷积操作+池化操作，但是不改变通道数，包括conv4和pool4。
        self.conv4 = nn.Conv2d(64, 64, 1)
        self.bn4 = nn.BatchNorm2d(64)
        # 第2个分支(包含3个卷积层)
        self.conv4_1 = nn.Conv2d(64, 32, 1)  # 第一个卷积层为conv4_1，使用的是1×1卷积,输入为64个通道，输出为32个通道
        self.bn4_1 = nn.BatchNorm2d(32)
        self.conv4_2 = nn.Conv2d(32, 32, 3, 2, 1)  # 第二个卷积层为conv4_2，输入为32个通道，输出为32个通道，使用3×3卷积，特征图空间大小减少
        self.bn4_2 = nn.BatchNorm2d(32)
        self.conv4_3 = nn.Conv2d(32, 64, 1)  # 第三个卷积层为conv4_3，输入大小为32个通道，输出大小为64个通道，使用1×1卷积
        self.bn4_3 = nn.BatchNorm2d(64)
        self.in_pool = nn.AvgPool2d(2)
        self.conv5 = nn.Conv2d(128, 256, 3, 1)
        self.bn5 = nn.BatchNorm2d(256)
        self.pool1 = nn.AdaptiveMaxPool2d(2)
        self.line1 = nn.Linear(256 * 2 * 2, 128)
        self.line2 = nn.Linear(128, 2)

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x = F.relu(self.bn3(self.conv3(x)))
        x1 = F.relu(self.bn4(self.conv4(x)))
        x1 = self.in_pool(x1)
        x2 = F.relu(self.bn4_1(self.conv4_1(x)))
        x2 = F.relu(self.bn4_2(self.conv4_2(x2)))
        x2 = F.relu(self.bn4_3(self.conv4_3(x2)))
        x = torch.cat((x1, x2), dim=1)  # 通道合并concat操作
        x = self.in_pool(x)
        x = F.relu(self.bn5(self.conv5(x)))
        x = self.pool1(x)
        x = x.view(-1, 256 * 2 * 2)
        x = F.relu(self.line1(x))
        x = self.line2(x)
        return x

模型结构

5 替换第5个卷积为Inception结构（conv5）

代码实现

class Inception_conv5(nn.Module):
    def __init__(self):
        super(Inception_conv5, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 3, 1)
        self.bn1 = nn.BatchNorm2d(16)
        self.conv2 = nn.Conv2d(16, 32, 3, 1)
        self.bn2 = nn.BatchNorm2d(32)
        self.conv3 = nn.Conv2d(32, 64, 3, 1)  
        self.bn3 = nn.BatchNorm2d(64)
        self.conv4 = nn.Conv2d(64, 128, 3, 1)
        self.bn4 = nn.BatchNorm2d(128)
        # 第1个分支
        # 使用常规的卷积操作+池化操作，但是不改变通道数，包括conv5和pool5。
        self.conv5 = nn.Conv2d(128, 128, 1)
        self.bn5 = nn.BatchNorm2d(128)
        # 第2个分支(包含3个卷积层)
        self.conv5_1 = nn.Conv2d(128, 64, 1)  # 第一个卷积层为conv5_1，使用的是1×1卷积,输入为128个通道，输出为64个通道
        self.bn5_1 = nn.BatchNorm2d(64)
        self.conv5_2 = nn.Conv2d(64, 64, 3, 2, 1)  # 第二个卷积层为conv5_2，输入为64个通道，输出为64个通道，使用3×3卷积，特征图空间大小减少
        self.bn5_2 = nn.BatchNorm2d(64)
        self.conv5_3 = nn.Conv2d(64, 128, 1)  # 第三个卷积层为conv5_3，输入大小为64个通道，输出大小为128个通道，使用1×1卷积
        self.bn5_3 = nn.BatchNorm2d(128)
        self.in_pool = nn.AvgPool2d(2)
        self.pool1 = nn.AdaptiveMaxPool2d(2)
        self.line1 = nn.Linear(256 * 2 * 2, 128)
        self.line2 = nn.Linear(128, 2)

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x = F.relu(self.bn3(self.conv3(x)))
        x = F.relu(self.bn4(self.conv4(x)))
        x1 = F.relu(self.bn5(self.conv5(x)))
        x1 = self.in_pool(x1)
        x2 = F.relu(self.bn5_1(self.conv5_1(x)))
        x2 = F.relu(self.bn5_2(self.conv5_2(x2)))
        x2 = F.relu(self.bn5_3(self.conv5_3(x2)))
        x = torch.cat((x1, x2), dim=1)  # 通道合并concat操作
        x = self.in_pool(x)
        x = self.pool1(x)
        x = x.view(-1, 256 * 2 * 2)
        x = F.relu(self.line1(x))
        x = self.line2(x)
        return x

模型结构

6 所有模型比较

某分类任务中基准模型、conv2、conv3、conv4、conv5的性能比较：

结论：

瓶颈模型的对应层参数量全部为原来的 $0.236$ ，计算量为原来的 $0.486$ ；
$1\times 1$ 卷积降低了参数量，且并未造成性能下降。

注： $1\times 1$ 卷积核可以实现通道降维和升维；
$3\times 3$ 卷积核可以实现特征降维。

$Inception$ 是通过增加网络的宽度来提高网络性能的，在每个 $Inception$ 模块中，使用了不同大小的卷积核，可以理解成不同的感受野，然后将其 $concentrate$ 起来，丰富了每层的信息。之后，使用了 $BN$ 算法（ $BN$ 使用在 $conv$ 之后， $relu$ 之前），来加速网络的收敛速度。