以下代码是阅读了torchvision中的GoogLeNet的实现后，复现出来的。
一、Inception模块的写法
每一个inception的结构都一样，不同就是输入输出的通道数不一样。所以可以写成一个Module，这样就可以复用。
以inception(3a)为例：
?代码：
# @file name : test.py
# @brief : Inception模块的写法
# @author : liupc
# @date : 2021/8/10
import torch
import torch.nn as nn
def BasicConv2d(in_channels, out_channels, **kwargs):
model = nn.Sequential(
nn.Conv2d(in_channels, out_channels, **kwargs),
nn.BatchNorm2d(out_channels),
nn.ReLU(),
)
return model
class Inception_block(nn.Module):
def __init__(self, in_channels, ch1x1, ch3x3red, ch3x3, ch5x5red, ch5x5, pool_proj):
#ch1x1: 第一个分支的通道数
#ch3x3red: 第二个分支的1x1卷积的通道数
#ch3x3: 第二个分支的3x3卷积的通道数
#ch5x5red: 第三个分支的1x1卷积的通道数
#ch5x5: 第三个分支的5x5卷积的通道数
#pool_proj: 第四个分支的通道数
super(Inception_block, self).__init__()
self.branch1 = BasicConv2d(in_channels, ch1x1, kernel_size=1) #经过1x1卷积
self.branch2 = nn.Sequential(
BasicConv2d(in_channels, ch3x3red, kernel_size=1),
BasicConv2d(ch3x3red, ch3x3, kernel_size=3, stride=1, padding=1),
)
self.branch3 = nn.Sequential(
BasicConv2d(in_channels, ch5x5red, kernel_size=1),
BasicConv2d(ch5x5red, ch5x5, kernel_size=3, stride=1, padding=1),
)
self.branch4 = nn.Sequential(
nn.MaxPool2d(kernel_size=3, stride=1, padding=1, ceil_mode=True),
BasicConv2d(in_channels, pool_proj, kernel_size=1)
)
def forward(self, x):
x1 = self.branch1(x) #B,C1,H,W
x2 = self.branch2(x) #B,C2,H,W
x3 = self.branch3(x) #B,C3,H,W
x4 = self.branch4(x) #B,C4,H,W
out = [x1, x2, x3, x4]
return torch.cat(out, 1)
if __name__ == "__main__":
inputs = torch.rand(2, 192, 28, 28)
inception = Inception_block(192, 64, 96, 128, 16, 32, 32)
outputs = inception(inputs)
print(outputs.shape)
运行结果：
在写一个模块的时候，其实就是写一个Module的类。这个类怎么写呢，通过这个例子可以看到有两种方式：第一种就是写一个class,继承nn.Module类，在里面写init函数和forward函数。另一种写法就是定义一个函数，里面通过nn.Sequential包装多个现成的Module,然后返回。
第一种写法适合那种比较复杂的情况，可以自由发挥。第二种情况适合于简单地将现成的模块进行组合的情况。
这两种写法都行吧，怎么熟悉怎么来，怎么方便怎么来。比如，在GoogLeNet中，他们 BasicConv2d就不是我这样定义的，而是：
#GoogLeNet中的BasicConv2d的写法
import torch.nn.functional as F
class BasicConv2d(nn.Module):
def __init__(self, in_channels, out_channels, **kwargs):
super(BasicConv2d, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
self.bn = nn.BatchNorm2d(out_channels, eps=0.001)
def forward(self, x):
x = self.conv(x)
x = self.bn(x)
return F.relu(x, inplace=True)当然也可以这么写了：
class BasicConv2d(nn.Module):
def __init__(self, in_channels, out_channels, **kwargs):
super(BasicConv2d, self).__init__()
self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
self.bn = nn.BatchNorm2d(out_channels, eps=0.001)
self.relu = nn.ReLU(inplace=True)
def forward(self, x):
x = self.conv(x)
x = self.bn(x)
x = self.relu(x)
return x这个写法还不如我的简便呢。。。随意写都行。。。不用太在意
二、辅助损失模块的写法
写了Inception之后，还可以把辅助损失的代码写成模块：
代码：
# @file name : auxloss.py
# @brief : 辅助损失模块的写法
# @author : liupc
# @date : 2021/8/10
import torch
import torch.nn as nn
from inception import BasicConv2d, Inception_block
class Auxloss_block(nn.Module):
def __init__(self, in_channels, num_classes=1000):
super(Auxloss_block, self).__init__()
self.avgpool = nn.AdaptiveAvgPool2d((4, 4)) # H和W变成4*4.
self.conv = BasicConv2d(in_channels, 128, kernel_size=1)
self.fc1 = nn.Linear(2048, 1024)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.7)
self.fc2 = nn.Linear(1024, num_classes)
def forward(self, x):
# aux1: N x 512 x 14 x 14, aux2: N x 528 x 14 x 14
x = self.avgpool(x) # N*512*4*4
x = self.conv(x) # N*128*4*4
x = torch.flatten(x, 1) # N* (128*4*4) = N *2048
x = self.fc1(x)
x = self.relu(x)
x = self.dropout(x)
x = self.fc2(x)
return x
if __name__ == "__main__":
inputs = torch.rand(2, 512, 14, 14)
net = Auxloss_block(512)
outputs = net(inputs)
print(outputs.shape)
?运行结果：
三、GoogLeNet的写法
有了Inception和辅助损失的模块之后，就可以写GoogLeNet了。
# @file name : googlenet.py
# @brief :
# @author : liupc
# @date : 2021/8/10
import torch
import torch.nn as nn
from inception import BasicConv2d, Inception_block
from auxloss import Auxloss_block
class GoogLeNet(nn.Module):
def __init__(self, num_classes=1000, aux_logits=False):
super(GoogLeNet, self).__init__()
self.aux_logits = aux_logits
#第一部分
self.conv1 = BasicConv2d(3, 64, kernel_size=7, stride=2, padding=3)
self.maxpool1 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
self.conv2 = BasicConv2d(64, 64, kernel_size=1)
self.conv3 = BasicConv2d(64, 192, kernel_size=3, padding=1)
self.maxpool2 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
#第二部分
self.inception3a = Inception_block(192, 64, 96, 128, 16, 32, 32)
self.inception3b = Inception_block(256, 128, 128, 192, 32, 96, 64)
self.maxpool3 = nn.MaxPool2d(3, stride=2, ceil_mode=True)
self.inception4a = Inception_block(480, 192, 96, 208, 16, 48, 64)
self.inception4b = Inception_block(512, 160, 112, 224, 24, 64, 64)
self.inception4c = Inception_block(512, 128, 128, 256, 24, 64, 64)
self.inception4d = Inception_block(512, 112, 144, 288, 32, 64, 64)
self.inception4e = Inception_block(528, 256, 160, 320, 32, 128, 128)
self.maxpool4 = nn.MaxPool2d(2, stride=2, ceil_mode=True)
self.inception5a = Inception_block(832, 256, 160, 320, 32, 128, 128)
self.inception5b = Inception_block(832, 384, 192, 384, 48, 128, 128)
#第三部分
self.avgpool = nn.AdaptiveAvgPool2d((1,1)) #H和W变成1*1.
self.classifier = nn.Sequential(
nn.Dropout(),
nn.Linear(1024, num_classes)
)
#第四部分
if aux_logits:
self.aux1 = Auxloss_block(512, num_classes)
self.aux2 = Auxloss_block(528, num_classes)
def forward(self, x):
#第一部分
x = self.conv1(x)
x = self.maxpool1(x)
x = self.conv2(x)
x = self.conv3(x)
x = self.maxpool2(x)
# 第二部分
x = self.inception3a(x)
x = self.inception3b(x)
x = self.maxpool3(x)
x = self.inception4a(x)
if self.training and self.aux_logits:
aux1 = self.aux1(x)
x = self.inception4b(x)
x = self.inception4c(x)
x = self.inception4d(x)
if self.training and self.aux_logits:
aux2 = self.aux2(x)
x = self.inception4e(x)
x = self.maxpool4(x)
x = self.inception5a(x)
x = self.inception5b(x)
# 第三部分
x = self.avgpool(x)
x = torch.flatten(x, 1) #由B*C*1*1 变为：B*C，才能经过FC层。
x = self.classifier(x)
if self.training and self.aux_logits:
return x, aux1, aux2
else:
return x
if __name__ == "__main__":
inputs = torch.rand(2, 3, 224, 224)
net = GoogLeNet(1000, aux_logits=True)
outputs, a1, a2 = net(inputs)
print(outputs.shape, a1.shape, a2.shape)
运行结果：
分别输出了最后的分类和两个辅助损失的分类，是对的。?