「深度学习一遍过」必修13：使用pytorch对Inception结构模型进行设计
Posted 荣仔！最靓的仔！
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了「深度学习一遍过」必修13：使用pytorch对Inception结构模型进行设计相关的知识，希望对你有一定的参考价值。
本专栏用于记录关于深度学习的笔记，不光方便自己复习与查阅，同时也希望能给您解决一些关于深度学习的相关问题，并提供一些微不足道的人工神经网络模型设计思路。
专栏地址：「深度学习一遍过」必修篇
目 录
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的性能比较：
结论：
- 瓶颈模型的对应层参数量全部为原来的
，计算量为原来的 
； 
卷积降低了参数量，且并未造成性能下降。
注：
卷积核可以实现特征降维。
是通过增加网络的宽度来提高网络性能的，在每个
起来，丰富了每层的信息。之后，使用了
算法（
之后，
之前），来加速网络的收敛速度。
欢迎大家交流评论，一起学习
希望本文能帮助您解决您在这方面遇到的问题
感谢阅读
END
以上是关于「深度学习一遍过」必修13：使用pytorch对Inception结构模型进行设计的主要内容，如果未能解决你的问题，请参考以下文章
「深度学习一遍过」必修3：Pytorch数据读取——使用Dataloader读取Dataset
「深度学习一遍过」必修18：基于pytorch的语义分割模型实现
「深度学习一遍过」必修17：基于Pytorch细粒度分类实战